import Limrun from '@limrun/api';

const lim = new Limrun({ apiKey: process.env['LIM_API_KEY'] });

const instance = await lim.iosInstances.create({
  wait: true,
  reuseIfExists: true,
  metadata: {
    labels: { app: 'my-app', session: 'demo' },
  },
  spec: {
    model: 'iphone',                    // 'iphone' | 'iphone-duo' | 'ipad' | 'watch'
    jurisdiction: 'us',                 // 'us' | 'eu' | 'as'; hard constraint on placement
    inactivityTimeout: '10m',           // '1m' | '10m' | '3h' | ...
    hardTimeout: '0',                   // '0' = no hard cap
    forceBundleId: 'com.example.myapp',
    clues: [{ kind: 'ClientIP', clientIp: '203.0.113.42' }],
    initialAssets: [
      { kind: 'App', source: 'AssetName', assetName: 'my-app-build.zip', launchMode: 'ForegroundIfRunning' },
    ],
  },
});

from limrun_api import Limrun

client = Limrun()
instance = client.ios_instances.create(
    wait=True,
    reuse_if_exists=True,
    metadata={"labels": {"app": "my-app", "session": "demo"}},
    spec={
        # The Python SDK has no jurisdiction or force_bundle_id field, and its model
        # type omits iphone-duo; use the CLI, the TypeScript SDK, or REST for those.
        "model": "iphone",                # "iphone" | "ipad" | "watch"
        "inactivity_timeout": "10m",
        "hard_timeout": "0",
        "clues": [{"kind": "ClientIP", "client_ip": "203.0.113.42"}],
        "initial_assets": [
            {
                "kind": "App",
                "source": "AssetName",
                "asset_name": "my-app-build.zip",
                "launch_mode": "ForegroundIfRunning",
            },
        ],
    },
)

import (
    "context"
    "os"

    limrun "github.com/limrun-inc/go-sdk"
    "github.com/limrun-inc/go-sdk/option"
    "github.com/limrun-inc/go-sdk/packages/param"
)

ctx := context.Background()
lim := limrun.NewClient(option.WithAPIKey(os.Getenv("LIM_API_KEY")))

// Go SDK v0.9.0 has no Model, Jurisdiction, or ForceBundleID field on the create
// params. Instances default to iPhone; use the CLI or REST for the others.
instance, err := lim.IosInstances.New(ctx, limrun.IosInstanceNewParams{
    Wait:          param.NewOpt(true),
    ReuseIfExists: param.NewOpt(true),
    Metadata: limrun.IosInstanceNewParamsMetadata{
        Labels: map[string]string{"app": "my-app", "session": "demo"},
    },
    Spec: limrun.IosInstanceNewParamsSpec{
        InactivityTimeout: param.NewOpt("10m"),
        HardTimeout:       param.NewOpt("0"),
        Clues: []limrun.IosInstanceNewParamsSpecClue{
            {Kind: "ClientIP", ClientIP: param.NewOpt("203.0.113.42")},
        },
        InitialAssets: []limrun.IosInstanceNewParamsSpecInitialAsset{
            {
                Kind:       "App",
                Source:     "AssetName",
                AssetName:  param.NewOpt("my-app-build.zip"),
                LaunchMode: "ForegroundIfRunning",
            },
        },
    },
})

# No client step: every command connects on its own.
lim ios screenshot ./out.jpg

import { Ios } from '@limrun/api';

const client = await Ios.createInstanceClient({
  apiUrl: instance.status.apiUrl!,
  token: instance.status.token!,   // absent for read-only keys and viewer seats
  logLevel: 'info',         // 'none' | 'error' | 'warn' | 'info' | 'debug'
});

console.log('UDID:', client.deviceInfo.udid);
console.log('Screen:', client.deviceInfo.screenWidth, client.deviceInfo.screenHeight);

import (
    "context"
    "os"

    limrun "github.com/limrun-inc/go-sdk"
    "github.com/limrun-inc/go-sdk/option"
    "github.com/limrun-inc/go-sdk/packages/param"
    iosws "github.com/limrun-inc/go-sdk/websocket/ios"
)

ctx := context.Background()

lim := limrun.NewClient(option.WithAPIKey(os.Getenv("LIM_API_KEY")))
inst, _ := lim.IosInstances.New(ctx, limrun.IosInstanceNewParams{
    Wait:          param.NewOpt(true),
    ReuseIfExists: param.NewOpt(true),
    Metadata: limrun.IosInstanceNewParamsMetadata{
        Labels: map[string]string{"session": "demo"},
    },
})

client, err := iosws.NewClient(inst.Status.APIURL, inst.Status.Token)
if err != nil { panic(err) }
defer client.Close()

lim ios element-tree
lim ios screenshot ./out.jpg

# The tree can be large: filter the JSON output with jq or grep so it does not
# fill an agent's context window.
lim ios element-tree --json | jq '.. | objects | select((.AXLabel // "") | contains("Continue"))'

const tree = await client.elementTree();
// tree: ElementTreeNode[] (recursive accessibility hierarchy)
// fields per node: AXLabel, AXUniqueId, AXValue, role, type, title, traits, frame, children

const shot = await client.screenshot();
// { base64: string, width: number, height: number }; base64 is JPEG data

treeJSON, err := client.ElementTree(ctx, nil)   // raw JSON; parse with encoding/json
shot, err := client.Screenshot(ctx)             // shot.Base64, shot.Width, shot.Height

lim ios tap-element --ax-unique-id startButton
lim ios tap-element --ax-label "Save"
lim ios tap-element --ax-label-contains continue
lim ios tap-element --type Button --ax-label "Done"
lim ios tap 201 450

// By accessibility identifier (most stable)
await client.tapElement({ AXUniqueId: 'startButton' });

// By label
await client.tapElement({ AXLabel: 'Save' });

// By label contains (case-insensitive)
await client.tapElement({ AXLabelContains: 'continue' });

// By type + label
await client.tapElement({ type: 'Button', AXLabel: 'Done' });

// By coordinates (last resort)
await client.tap(201, 450);

// ctx and client come from the connect step above.
// Selector field names differ slightly from TypeScript:
//   AccessibilityID, Label, LabelContains, ElementType, Title, TitleContains, Value
_, err := client.TapElement(ctx, iosws.AccessibilitySelector{
    AccessibilityID: "startButton",
})
_, err = client.TapElement(ctx, iosws.AccessibilitySelector{
    Label: "Save",
})
_, err = client.TapElement(ctx, iosws.AccessibilitySelector{
    ElementType: "Button",
    Label:       "Done",
})
err = client.Tap(ctx, 201, 450)

lim ios set-text "42" --ax-label Count
lim ios set-text "P@ssw0rd!" --focused

await client.incrementElement({ AXLabel: 'Volume' });
await client.decrementElement({ AXLabel: 'Volume' });
await client.setElementValue('42', { AXLabel: 'Count' });   // sets the exact value, no keyboard involved
await client.setElementValue('P@ssw0rd!');                  // no selector: targets the focused field

lim ios type "hello world" --enter          # press Enter after typing
lim ios type "hi" --no-require-focus
lim ios press-key @                         # shifted symbols work directly
lim ios press-key enter --modifier shift
lim ios toggle-keyboard

await client.typeText('hello world');                   // types into focused field
await client.typeText('[email protected]', true);       // pressEnter = true
await client.typeText('hi', false, { requireFocus: false }); // skip the focus check
await client.pressKey('enter');
await client.pressKey('a', ['shift']);                   // modifiers: shift, command, control, alt
await client.toggleKeyboard();

err := client.TypeText(ctx, "hello world", false)
err = client.TypeText(ctx, "[email protected]", true) // pressEnter
err = client.PressKey(ctx, "enter")
err = client.PressKey(ctx, "a", "shift")
// toggleKeyboard is not in Go SDK v0.9.0.

lim ios scroll down --amount 300
lim ios scroll up --amount 300 --momentum 0.4 --coordinate 200,400

await client.scroll('down', 300);
await client.scroll('up',   300, { coordinate: [200, 400], momentum: 0.4 });

await client.setOrientation('Portrait');
await client.setOrientation('Landscape');

err = client.SetOrientation(ctx, iosws.OrientationPortrait)
err = client.SetOrientation(ctx, iosws.OrientationLandscape)

lim ios open-url "https://apple.com"
lim ios open-url "myapp://orders/42"

await client.openUrl('https://apple.com');               // opens in Safari
await client.openUrl('myapp://orders/42');               // deep link into your app

err = client.OpenURL(ctx, "https://apple.com")
err = client.OpenURL(ctx, "myapp://orders/42")

lim ios perform \
  --action 'type=tapElement,selector={"AXLabel":"Continue"}' \
  --action type=wait,durationMs=500 \
  --action "type=typeText,text=hello,pressEnter=true"

const result = await client.performActions(
  [
    { type: 'tapElement', selector: { AXLabel: 'Continue' } },
    { type: 'wait', durationMs: 500 },
    { type: 'typeText', text: 'hello', pressEnter: true },
    { type: 'scroll', direction: 'down', pixels: 300 },
    { type: 'pressKey', key: 'enter' },
  ],
  { timeoutMs: 10_000 },
);
// result.results has one entry per action; a failing action rejects the call instead

lim ios list-apps
lim ios launch-app com.example.MyApp --mode RelaunchIfRunning
lim ios terminate-app com.example.MyApp
lim ios install-app ./MyApp.app.zip
lim ios install-app https://... --md5 abc... --launch-mode ForegroundIfRunning

const apps = await client.listApps();
// [{ bundleId, name, installType }, ...]

await client.launchApp('com.example.MyApp');
await client.launchApp('com.example.MyApp', 'RelaunchIfRunning');
await client.launchApp('com.example.MyApp', {
  mode: 'RelaunchIfRunning',
  onExit: async (logs) => {
    console.log('App exited. Last lines from this launch:');
    for (const line of logs) console.log(line);
  },
});
await client.terminateApp('com.example.MyApp');

// Install from a URL (md5 enables server-side caching)
await client.installApp('https://...build.zip', {
  md5: '...',
  timeoutMs: 120_000,
  launchMode: 'ForegroundIfRunning',
});

apps, err := client.ListApps(ctx)
// []InstalledApp{ BundleID, Name, InstallType }

err = client.LaunchApp(ctx, "com.example.MyApp")
result, err := client.InstallApp(ctx, "https://...build.zip", &iosws.AppInstallationOptions{
    MD5:        "...",
    LaunchMode: "ForegroundIfRunning",
})
// terminateApp is not in Go SDK v0.9.0; use `lim ios terminate-app` instead.

lim ios app-log com.example.MyApp --tail 200
lim ios app-log com.example.MyApp --follow

// One-shot tail
const tail = await client.appLogTail('com.example.MyApp', 200);

// Stream live
const stream = client.streamAppLog('com.example.MyApp');
stream.on('line', (line) => console.log(line));
stream.on('error', console.error);
stream.on('close', () => console.log('stream closed'));
stream.stop();   // unsubscribe when done

lim ios record start --quality 5
# ... drive the UI ...
lim ios record stop -o /tmp/demo.mp4
# or upload straight to your own bucket:
lim ios record stop --presigned-url "<url>"

await client.startRecording({ quality: 5 });
// ... drive the UI ...
const downloadUrl = await client.stopRecording({ localPath: '/tmp/demo.mp4' });
// or:
await client.stopRecording({ presignedUrl: '<your-s3-upload-url>' });

lim ios camera play ./fixtures/qr-scan.mp4
lim ios camera play ./fixtures/intro.mp4 --no-loop
lim ios camera clear

await client.setCameraVideo('./fixtures/qr-scan.mp4');                 // loops by default
await client.setCameraVideo('./fixtures/intro.mp4', { loop: false }); // play once
await client.clearCameraVideo();                                       // back to the live camera

lim ios clipboard set "123456"
echo "123456" | lim ios clipboard set
lim ios clipboard get

// Run simctl pbcopy and pbpaste; pbcopy reads its text from the stdin option.
await client.simctl(['pbcopy', 'booted'], { stdin: '123456' }).wait();
const { stdout: clipboard } = await client.simctl(['pbpaste', 'booted']).wait();

lim ios defaults -- write -g AppleLanguages -array fr-FR
lim ios defaults -- write -g AppleLocale -string fr_FR
lim ios defaults -- read -g AppleLanguages

await client.simctl(['spawn', 'booted', 'defaults', 'write', '-g', 'AppleLanguages', '-array', 'fr-FR']).wait();

lim ios notify set com.apple.BiometricKit.enrollmentChanged 1
lim ios notify post com.apple.BiometricKit.enrollmentChanged
lim ios notify post com.apple.BiometricKit_Sim.pearl.match     # the next scan succeeds
lim ios notify post com.apple.BiometricKit_Sim.pearl.nomatch   # the next scan fails

// notify post, set, and get are notifyutil -p, -s, and -g.
await client.simctl(['spawn', 'booted', 'notifyutil', '-p', 'com.apple.BiometricKit_Sim.pearl.match']).wait();

lim ios ls Documents --bundle-id com.example.app --container-type data
lim ios pull-file Documents/recording.mov ./recording.mov \
  --bundle-id com.example.app --container-type data
lim ios push-file ./fixture.json Documents/fixture.json \
  --bundle-id com.example.app --container-type data
lim ios delete-file Documents/fixture.json \
  --bundle-id com.example.app --container-type data

import { writeFile } from 'node:fs/promises';

// Pass the same container options to each call.
const container = {
  bundleId: 'com.example.app',
  containerType: 'data',
};

const entries = await client.listFiles('Documents', container);
// [{ name: 'recording.mov', path: 'Documents/recording.mov',
//    isDirectory: false, size: 123456 }]

const recording = await client.pullFile(entries[0].path, container);
await writeFile('./recording.mov', recording);

lim ios create --model iphone-duo
lim ios fold --json --id <instance-id>
lim ios fold 90 --orientation landscape-left --id <instance-id>
lim ios fold 0 --id <instance-id>
lim ios fold 180 --id <instance-id>
lim ios screenshot ./inner.jpg --display inner --id <instance-id>
lim ios tap 300 200 --display inner --id <instance-id>

const fold = await client.getFoldState(); // null on an ordinary simulator
await client.setHingeAngle(110);
await client.setDuoOrientation('landscape-left');
const inner = await client.screenshotDisplay('inner');
await client.tapDisplay('inner', inner.width / 2, inner.height / 2);

lim ios simctl -- listapps booted
lim ios xcrun  -- --sdk iphonesimulator --show-sdk-version
lim ios xcodebuild -- -version
lim ios lsof

// Streaming simctl
const exec = client.simctl(['listapps', 'booted']);
exec.on('line-stdout', (line) => console.log(line));
exec.on('line-stderr', (line) => console.error(line));
const { code } = await exec.wait();

// One-shot xcrun (limited to --sdk / --show-* flags)
const { stdout } = await client.xcrun(['--sdk', 'iphonesimulator', '--show-sdk-version']);

// xcodebuild version only
await client.xcodebuild(['-version']);

// Upload a local file to the simulator staging folder (returns the path on the host)
const remotePath = await client.pushFile('/local/path/to/config.json', 'config.json');

// Inspect open UNIX sockets
const sockets = await client.lsof();

// simctl mirrors os/exec.Cmd; pipe to your own writers or buffer the output.
cmd := client.Simctl(ctx, "listapps", "booted")
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if err := cmd.Run(); err != nil { panic(err) }

// Inspect open UNIX sockets
sockets, err := client.Lsof(ctx)

// xcrun, xcodebuild, and file transfer are not in Go SDK v0.9.0.

lim ios create --reuse-if-exists --label session=<session-id> --label user=<user-id>

const instance = await lim.iosInstances.create({
  wait: true,
  reuseIfExists: true,
  metadata: { labels: { session: sessionId, user: userId } },
});

instance = client.ios_instances.create(
    wait=True,
    reuse_if_exists=True,
    metadata={"labels": {"session": session_id, "user": user_id}},
)

instance, err := lim.IosInstances.New(ctx, limrun.IosInstanceNewParams{
    Wait:          param.NewOpt(true),
    ReuseIfExists: param.NewOpt(true),
    Metadata: limrun.IosInstanceNewParamsMetadata{
        Labels: map[string]string{"session": sessionID, "user": userID},
    },
})
if err != nil {
    panic(err)
}

lim ios list --label-selector "agent=ci,issue=LIM-34"
lim ios delete <instance-id>

await lim.iosInstances.delete(instance.metadata.id);

const stale = await lim.iosInstances.list({ labelSelector: `user=${userId}`, state: 'ready' });
for await (const inst of stale) {
  await lim.iosInstances.delete(inst.metadata.id);
}

client.ios_instances.delete(instance.metadata.id)

params = {"label_selector": f"user={user_id}", "state": "ready"}
while page := client.ios_instances.list(**params).items:
    for inst in page:
        client.ios_instances.delete(inst.metadata.id)
    # Page by hand: the iterator stops after the first page.
    params["starting_after"] = page[-1].metadata.id

if err := lim.IosInstances.Delete(ctx, instance.Metadata.ID); err != nil {
    panic(err)
}

// Page by hand: ListAutoPaging panics on instance lists.
params := limrun.IosInstanceListParams{
    LabelSelector: param.NewOpt("user=" + userID),
    State:         param.NewOpt("ready"),
}
for {
    page, err := lim.IosInstances.List(ctx, params)
    if err != nil {
        panic(err)
    }
    if len(page.Items) == 0 {
        break
    }
    for _, inst := range page.Items {
        if err := lim.IosInstances.Delete(ctx, inst.Metadata.ID); err != nil {
            panic(err)
        }
    }
    params.StartingAfter = param.NewOpt(page.Items[len(page.Items)-1].Metadata.ID)
}