@testin-official/xagent 0.3.7

package/dist/cli.js

@@ -0,0 +1,529 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import { stdin as input, stdout as output } from "node:process";
+import { Command } from "commander";
+import { fileURLToPath } from "node:url";
+import { AuthoringDraftStore } from "./authoring/draft-store.js";
+import { buildDeviceActionRequest } from "./action/protocol.js";
+import { SessionLeaseManager } from "./authoring/session-lease.js";
+import { CredentialResolver } from "./config/credentials.js";
+import { ConfigStore, Profile } from "./config/store.js";
+import { CliError, XAgentApiError } from "./core/errors.js";
+import { onInterrupt } from "./core/interrupt.js";
+import { CANONICAL_SCRIPT_SCHEMA_VERSION, CONFIG_SCHEMA_VERSION, DEVELOPER_API_VERSION, PRINCIPAL_SCHEMA_VERSION, PROJECT_SCHEMA_VERSION, PUBLIC_SCRIPT_SCHEMA_VERSION, VERSION } from "./core/version.js";
+import { loadProjectConfig } from "./project/config.js";
+import { createRunProgressReporter } from "./run/progress.js";
+import { parseYaml } from "./script/service.js";
+import { XAgentClient } from "./sdk/client.js";
+import { exportSkills, listSkillReferences, listSkills, readSkill, readSkillReference } from "./skills/catalog.js";
+import { runStdioServer } from "./mcp/server.js";
+import { MCP_MODES } from "./mcp/tools.js";
+import { detectHost, doctorHost, HOSTS, installHost, routeOutput, syncHost, uninstallHost, verifySkillDirectory } from "./integrations/manager.js";
+import { DEFAULT_WORKFLOW_DOMAIN, USER_WORKFLOW_DOMAINS, USER_WORKFLOW_ROUTES, routeForDomain } from "./integrations/routing.js";
+const API_EXIT = {
+    invalid_request: 2, schema_invalid: 2, configuration_invalid: 2, target_not_found: 2, target_invalid: 2,
+    target_hash_mismatch: 2, idempotency_conflict: 2, authoring_state_invalid: 2, revision_conflict: 2, action_in_progress: 2, observation_stale: 2,
+    attempt_in_progress: 2, authentication_required: 3, token_invalid: 3, token_expired: 3, token_revoked: 3,
+    token_type_mismatch: 3, permission_denied: 3, cancelled: 4, device_unavailable: 5, resource_not_found: 5,
+    authoring_session_expired: 5, authoring_session_not_active: 5,
+    test_failed: 1, infrastructure_failed: 6, invalid_response: 6, authoring_session_renewal_failed: 6, timeout: 7,
+};
+function context(command) {
+    const options = command.optsWithGlobals();
+    return { json: Boolean(options.json), profile: options.profile, userConfig: options.userConfig, projectConfig: options.config, nonInteractive: Boolean(options.nonInteractive), config: new ConfigStore(options.userConfig) };
+}
+function emit(ctx, data, human) {
+    if (ctx.json)
+        process.stdout.write(`${JSON.stringify(data)}\n`);
+    else if (human)
+        process.stdout.write(`${human}\n`);
+    else
+        process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+}
+function unexpected(error) {
+    // Keep whatever the runtime actually threw. Collapsing every unexpected
+    // error to a bare "XAgent command failed" left no way to tell a broken
+    // socket apart from a bad path or an out-of-memory failure.
+    const cause = error instanceof Error ? error : undefined;
+    const message = (cause?.message ?? String(error ?? "")).trim();
+    const details = {};
+    if (cause?.name)
+        details.cause_name = cause.name;
+    const causeCode = error?.code ?? cause?.cause?.code;
+    if (causeCode !== undefined)
+        details.cause_code = String(causeCode);
+    if (cause?.stack)
+        details.cause_stack = cause.stack.split("\n").slice(0, 6).join("\n");
+    return new CliError("infrastructure_failed", message ? `XAgent command failed: ${message}` : "XAgent command failed", 6, details);
+}
+function fail(error) {
+    const known = error instanceof CliError || error instanceof XAgentApiError ? error : unexpected(error);
+    const json = process.argv.includes("--json");
+    const payload = known.toJSON();
+    if (json)
+        process.stdout.write(`${JSON.stringify({ error: payload })}\n`);
+    else
+        process.stderr.write(`Error: ${String(payload.message)}\n${payload.application_url ? `Apply at: ${payload.application_url}\n` : ""}`);
+    process.exit(API_EXIT[known.code] ?? (known instanceof CliError ? known.exitCode : 6));
+}
+function tokenApplicationUrl(baseUrl, tokenType) {
+    try {
+        const url = new URL(baseUrl);
+        return `${url.origin}/agent/developer-tokens/index.html?type=${encodeURIComponent(tokenType)}`;
+    }
+    catch {
+        return `${baseUrl.replace(/\/+$/, "")}/agent/developer-tokens/index.html?type=${encodeURIComponent(tokenType)}`;
+    }
+}
+async function readSecret(prompt) {
+    if (!input.isTTY || typeof input.setRawMode !== "function")
+        throw new CliError("authentication_required", "--token-stdin is required when no interactive terminal is available", 3);
+    output.write(prompt);
+    input.setRawMode(true);
+    input.resume();
+    return new Promise((resolve, reject) => {
+        let value = "";
+        const finish = (error) => {
+            input.off("data", onData);
+            input.setRawMode(false);
+            input.pause();
+            output.write("\n");
+            if (error)
+                reject(error);
+            else
+                resolve(value);
+        };
+        const onData = (chunk) => {
+            for (const character of chunk.toString("utf8")) {
+                if (character === "\r" || character === "\n") {
+                    finish();
+                    return;
+                }
+                if (character === "\u0003") {
+                    finish(new CliError("cancelled", "Token input was cancelled", 4));
+                    return;
+                }
+                if (character === "\b" || character === "\u007f")
+                    value = value.slice(0, -1);
+                else
+                    value += character;
+            }
+        };
+        input.on("data", onData);
+    });
+}
+async function selectedProfile(ctx) { return ctx.config.getProfile(ctx.profile); }
+async function authenticatedClient(ctx, uploadTimeoutMs) {
+    const profile = await selectedProfile(ctx);
+    let token;
+    try {
+        token = await new CredentialResolver().resolve(profile);
+    }
+    catch (error) {
+        if (error instanceof CliError && error.code === "authentication_required")
+            throw new CliError(error.code, error.message, 3, { required_token_type: profile.data.expected_token_type, application_url: profile.data.token_apply_url });
+        throw error;
+    }
+    const client = new XAgentClient(profile.data.base_url, token, profile.data.upload_base_url, 30_000, uploadTimeoutMs ?? 900_000);
+    return { profile, client };
+}
+async function withFreshSession(ctx, sessionId, operation) {
+    const { client } = await authenticatedClient(ctx);
+    const manager = new SessionLeaseManager(client.authoring);
+    await manager.ensureFresh(sessionId);
+    try {
+        return await operation(client);
+    }
+    finally {
+        manager.unregister(sessionId);
+    }
+}
+async function withFreshActionSession(ctx, sessionId, operation) {
+    const { client } = await authenticatedClient(ctx);
+    const manager = new SessionLeaseManager(client.action);
+    await manager.ensureFresh(sessionId);
+    try {
+        return await operation(client);
+    }
+    finally {
+        manager.unregister(sessionId);
+    }
+}
+async function loadScript(file) {
+    let content;
+    try {
+        content = await readFile(file, "utf8");
+    }
+    catch {
+        throw new CliError("script_read_failed", `unable to read ${file}`);
+    }
+    const parsed = await parseYaml(content);
+    if (!parsed.valid)
+        throw new CliError("schema_invalid", "YAML script validation failed", 2, { issues: parsed.issues });
+    return { ...parsed, content };
+}
+function requireProjectCi(profile, commandName) { if (profile.data.expected_token_type !== "project_ci")
+    throw new CliError("token_type_mismatch", `${commandName} requires a project_ci Profile`, 3); }
+function parseVariables(values) { const result = {}; for (const value of values) {
+    const split = value.indexOf("=");
+    if (split <= 0)
+        throw new CliError("invalid_request", "--var must use NAME=VALUE");
+    result[value.slice(0, split).trim()] = value.slice(split + 1);
+} return result; }
+function billingText(value) {
+    const billing = value?.billing ?? value?.session?.billing;
+    return billing ? ` billing=${billing.status} minutes=${billing.billable_minutes} cost=${billing.cost}` : "";
+}
+function emitRun(ctx, run, useStatusExit = true) { emit(ctx, run, `Run ${run.id} status=${run.status}${billingText(run)}`); if (!useStatusExit)
+    return; process.exitCode = { failed: 1, cancelled: 4, infrastructure_failed: 6, timed_out: 7 }[run.status] ?? 0; }
+function progressReporter(ctx) { return createRunProgressReporter(ctx); }
+const program = new Command().name("xagent").description("XAgent Developer CLI").showHelpAfterError();
+program.option("--json", "Emit stable JSON output").option("--profile <name>", "Select a named authentication Profile").option("--config <path>", "Use a project xagent.yaml").option("--user-config <path>", "Use an explicit user Profile configuration").option("--non-interactive", "Disable interactive prompts");
+program.command("version").description("Show CLI and contract versions").action(async function () {
+    const ctx = context(this);
+    emit(ctx, { version: VERSION, developer_api_version: DEVELOPER_API_VERSION, config_schema_version: CONFIG_SCHEMA_VERSION, project_schema_version: PROJECT_SCHEMA_VERSION, principal_schema_version: PRINCIPAL_SCHEMA_VERSION, public_script_schema_version: PUBLIC_SCRIPT_SCHEMA_VERSION, canonical_script_schema_version: CANONICAL_SCRIPT_SCHEMA_VERSION }, `xagent ${VERSION}`);
+});
+program.command("doctor").description("Check local configuration and credential source").action(async function () {
+    const ctx = context(this);
+    const payload = await ctx.config.load();
+    const profile = ctx.profile || payload.default_profile;
+    emit(ctx, { checks: { configuration: "ok", profile: profile ? "ok" : "not_configured", credential_source: profile && payload.profiles[profile] && (payload.profiles[profile].credential_env || payload.profiles[profile].credential_ref) ? "configured" : "not_configured", online_checks_performed: false } }, "Local configuration is valid");
+});
+const config = program.command("config");
+config.command("path").action(async function () { const ctx = context(this); emit(ctx, { path: ctx.config.filePath }, ctx.config.filePath); });
+config.command("validate").action(async function () { const ctx = context(this); await ctx.config.load(); emit(ctx, { valid: true, schema_version: CONFIG_SCHEMA_VERSION }, "Configuration is valid"); });
+config.command("show").action(async function () { const ctx = context(this); const payload = await ctx.config.load(); emit(ctx, { schema_version: payload.schema_version, default_profile: payload.default_profile, profiles: Object.fromEntries(Object.entries(payload.profiles).sort(([a], [b]) => a.localeCompare(b)).map(([name, item]) => [name, Profile.from(name, item).publicData()])) }); });
+const profiles = program.command("profiles");
+profiles.command("add").argument("<name>").requiredOption("--base-url <url>").requiredOption("--expected-token-type <type>").option("--token-env <name>").option("--token-apply-url <url>").option("--upload-base-url <url>").option("--use").action(async function (name, options) { const ctx = context(this); const data = { base_url: options.baseUrl, expected_token_type: options.expectedTokenType, ...(options.tokenEnv ? { credential_env: options.tokenEnv } : {}), ...(options.uploadBaseUrl ? { upload_base_url: options.uploadBaseUrl } : {}), token_apply_url: options.tokenApplyUrl ?? tokenApplicationUrl(options.baseUrl, options.expectedTokenType) }; const profile = Profile.from(name, data); await ctx.config.putProfile(profile); if (options.use)
+    await ctx.config.useProfile(name); emit(ctx, profile.publicData(), `Profile '${name}' added`); });
+profiles.command("list").action(async function () { const ctx = context(this); const payload = await ctx.config.load(); emit(ctx, { profiles: (await ctx.config.listProfiles()).map((profile) => ({ ...profile.publicData(), default: profile.name === payload.default_profile })) }); });
+profiles.command("show").argument("[name]").action(async function (name) { const ctx = context(this); const profile = await ctx.config.getProfile(name ?? ctx.profile); emit(ctx, profile.publicData()); });
+profiles.command("use").argument("<name>").action(async function (name) { const ctx = context(this); await ctx.config.useProfile(name); emit(ctx, { default_profile: name }, `Profile '${name}' selected`); });
+profiles.command("remove").argument("<name>").action(async function (name) { const ctx = context(this); const profile = await ctx.config.getProfile(name); await new CredentialResolver().delete(profile); await ctx.config.removeProfile(name); emit(ctx, { removed: name }, `Profile '${name}' removed`); });
+const auth = program.command("auth");
+auth.command("status").action(async function () { const ctx = context(this); const { profile, client } = await authenticatedClient(ctx); const principal = await client.getPrincipal(); if (principal.token_type !== profile.data.expected_token_type)
+    throw new CliError("token_type_mismatch", `Profile expects ${profile.data.expected_token_type}, server resolved ${principal.token_type}`, 3); emit(ctx, { profile: profile.name, principal }, `${profile.name}: ${principal.token_type} eid=${principal.eid} project=${principal.project_id}`); });
+auth.command("login").option("--save").option("--token-stdin").action(async function (options) { const ctx = context(this); const profile = await selectedProfile(ctx); if (!options.tokenStdin && !ctx.json)
+    process.stderr.write(`Token 申请地址：${profile.data.token_apply_url ?? tokenApplicationUrl(profile.data.base_url, profile.data.expected_token_type)}\n`); let token = ""; if (options.tokenStdin)
+    token = (await readFile(0, "utf8")).trim().replace(/^\uFEFF/, "");
+else if (ctx.nonInteractive)
+    throw new CliError("authentication_required", "--token-stdin is required in non-interactive mode", 3);
+else
+    token = (await readSecret("Developer Token: ")).trim(); if (!token)
+    throw new CliError("authentication_required", "Developer Token is required", 3); const client = new XAgentClient(profile.data.base_url, token); let principal; try {
+    principal = await client.getPrincipal();
+}
+catch (error) {
+    if (error instanceof XAgentApiError && ["token_invalid", "token_expired", "token_revoked"].includes(error.code))
+        throw new CliError(error.code, error.message, 3, { required_token_type: profile.data.expected_token_type, application_url: profile.data.token_apply_url });
+    throw error;
+} if (principal.token_type !== profile.data.expected_token_type)
+    throw new CliError("token_type_mismatch", `Profile expects ${profile.data.expected_token_type}, server resolved ${principal.token_type}`, 3); let saved = false; if (options.save) {
+    const resolver = new CredentialResolver();
+    const reference = await resolver.save(profile, token);
+    try {
+        await ctx.config.setCredentialReference(profile.name, reference);
+    }
+    catch (error) {
+        await resolver.store.delete(reference);
+        throw error;
+    }
+    saved = true;
+} emit(ctx, { profile: profile.name, saved, principal }, `Authenticated Profile '${profile.name}'`); });
+auth.command("logout").action(async function () { const ctx = context(this); const profile = await selectedProfile(ctx); await new CredentialResolver().delete(profile); await ctx.config.setCredentialReference(profile.name); emit(ctx, { profile: profile.name, credential_removed: true }, `Profile '${profile.name}' logged out`); });
+program.command("init").requiredOption("--base-url <url>").option("--token-type <type>", undefined, "personal").option("--name <name>", undefined, "default").option("--token-env <name>").option("--token-apply-url <url>").option("--upload-base-url <url>").action(async function (options) { const ctx = context(this); const profile = Profile.from(options.name, { base_url: options.baseUrl, expected_token_type: options.tokenType, ...(options.tokenEnv ? { credential_env: options.tokenEnv } : {}), ...(options.uploadBaseUrl ? { upload_base_url: options.uploadBaseUrl } : {}), token_apply_url: options.tokenApplyUrl ?? tokenApplicationUrl(options.baseUrl, options.tokenType) }); await ctx.config.putProfile(profile); await ctx.config.useProfile(profile.name); emit(ctx, profile.publicData(), `Profile '${profile.name}' initialized`); if (!ctx.json)
+    process.stderr.write(`Token 申请地址：${profile.data.token_apply_url}\n`); });
+program.command("validate").argument("<scriptFile>").action(async function (file) { const ctx = context(this); const parsed = await loadScript(file); emit(ctx, { valid: true, schema_version: parsed.inputSchemaVersion ?? parsed.script.schema_version, execution_schema_version: parsed.script.schema_version, source_hash: parsed.sourceHash, step_count: parsed.script.steps.length }, `${file}: valid (${parsed.script.steps.length} steps)`); });
+const skills = program.command("skills");
+skills.command("list").action(async function () { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.listEffectiveSkills()); });
+skills.command("show").argument("<name>").action(async function (name) { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.getEffectiveSkill(name)); });
+skills.command("reference").argument("<name>").argument("<path>").action(async function (name, reference) { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.getEffectiveSkillReference(name, reference)); });
+const packaged = skills.command("packaged");
+packaged.command("list").action(async function () { const ctx = context(this); emit(ctx, { skills: listSkills() }); });
+packaged.command("show").argument("<name>").action(async function (name) { const ctx = context(this); try {
+    emit(ctx, { name, content: await readSkill(name) });
+}
+catch {
+    throw new XAgentApiError("resource_not_found", "Skill was not found");
+} });
+packaged.command("references").argument("<name>").action(async function (name) { const ctx = context(this); try {
+    emit(ctx, { name, references: await listSkillReferences(name) });
+}
+catch {
+    throw new XAgentApiError("resource_not_found", "Skill was not found");
+} });
+packaged.command("reference").argument("<name>").argument("<path>").action(async function (name, reference) { const ctx = context(this); try {
+    emit(ctx, { name, path: reference, content: await readSkillReference(name, reference) });
+}
+catch {
+    throw new XAgentApiError("resource_not_found", "Skill Reference was not found");
+} });
+packaged.command("export").argument("<directory>").option("--overwrite").action(async function (directory, options) { const ctx = context(this); emit(ctx, { written: await exportSkills(directory, Boolean(options.overwrite)) }); });
+function hostArgument(value) {
+    if (!HOSTS.includes(value))
+        throw new CliError("invalid_request", `host must be one of: ${HOSTS.join(", ")}`);
+    return value;
+}
+function domainArgument(value) {
+    if (!USER_WORKFLOW_DOMAINS.includes(value))
+        throw new CliError("invalid_request", `user behavior domain must be one of: ${USER_WORKFLOW_DOMAINS.join(", ")}`);
+    return value;
+}
+const integrations = program.command("integrations").description("Install and verify the XAgent Agent Host Skill");
+integrations.command("detect").option("--host <host>").action(async function (options) {
+    const ctx = context(this);
+    emit(ctx, { hosts: await detectHost(options.host ? hostArgument(options.host) : undefined) });
+});
+integrations.command("install").argument("<host>").option("--force", "Overwrite the existing XAgent Skill only").action(async function (host, options) {
+    const ctx = context(this);
+    emit(ctx, await installHost(hostArgument(host), Boolean(options.force)), `Installed xagent-skill for ${host}`);
+});
+integrations.command("doctor").option("--host <host>").action(async function (options) {
+    const ctx = context(this);
+    emit(ctx, { checks: await doctorHost(options.host ? hostArgument(options.host) : undefined) });
+});
+integrations.command("sync").option("--host <host>").action(async function (options) {
+    const ctx = context(this);
+    emit(ctx, { synced: await syncHost(options.host ? hostArgument(options.host) : undefined) });
+});
+integrations.command("uninstall").argument("<host>").requiredOption("--force", "Confirm removal of the XAgent Skill directory").action(async function (host, options) {
+    const ctx = context(this);
+    emit(ctx, await uninstallHost(hostArgument(host), Boolean(options.force)), `Removed xagent-skill for ${host}`);
+});
+integrations.command("verify-skill").argument("<directory>").action(async function (directory) {
+    const ctx = context(this);
+    const result = await verifySkillDirectory(directory);
+    emit(ctx, result, result.valid ? "XAgent Skill is compatible" : "XAgent Skill is incompatible");
+    if (!result.valid)
+        process.exitCode = 2;
+});
+integrations.command("route").argument("<domain>").option("--profile <name>", "Profile name to include in the MCP command").action(async function (domain, options) {
+    const ctx = context(this);
+    const selected = domainArgument(domain);
+    routeForDomain(selected);
+    emit(ctx, routeOutput(selected, options.profile ?? ctx.profile));
+});
+integrations.command("options").action(async function () {
+    const ctx = context(this);
+    emit(ctx, {
+        default_domain: DEFAULT_WORKFLOW_DOMAIN,
+        default_mode: routeForDomain(DEFAULT_WORKFLOW_DOMAIN).mode,
+        choices: USER_WORKFLOW_ROUTES.map(({ domain, mode, skill, side_effects, description }) => ({ domain, mode, skill, side_effects, description })),
+        selection_required_before_side_effects: true,
+    });
+});
+const authoring = program.command("authoring");
+authoring.command("start").requiredOption("--device-id <id>").requiredOption("--idempotency-key <key>").action(async function (options) { const ctx = context(this); const result = await (await authenticatedClient(ctx)).client.authoring.createSession(options.deviceId, options.idempotencyKey); emit(ctx, result, `Authoring Session ${result.id} status=${result.status}${billingText(result)}`); });
+authoring.command("show").argument("<sessionId>").action(async function (sessionId) { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.authoring.getSession(sessionId)); });
+authoring.command("renew").argument("<sessionId>").action(async function (sessionId) { const ctx = context(this); const result = await (await authenticatedClient(ctx)).client.authoring.renewSession(sessionId); emit(ctx, result, `Authoring Session ${result.id} renewed until ${result.expires_at}${billingText(result)}`); });
+authoring.command("keepalive").argument("<sessionId>").option("--poll-interval <seconds>", undefined, "30").action(async function (sessionId, options) {
+    const ctx = context(this);
+    const { client } = await authenticatedClient(ctx);
+    const manager = new SessionLeaseManager(client.authoring, { onEvent: (event) => emit(ctx, event, event.type === "renewed" ? `Authoring Session ${event.session_id} renewed until ${event.expires_at ?? "unknown"}` : undefined) });
+    // Ctrl+C stops this foreground keepalive without cancelling the Session;
+    // the user can explicitly run `authoring cancel` when the work is finished.
+    const deregister = onInterrupt(async () => { manager.unregister(sessionId); });
+    try {
+        await manager.keepAlive(sessionId, { pollMs: Number(options.pollInterval) * 1000 });
+        emit(ctx, { session_id: sessionId, status: "TERMINAL", lease: manager.getLease(sessionId) ?? null }, `Authoring Session ${sessionId} is terminal`);
+    }
+    finally {
+        deregister();
+        manager.unregister(sessionId);
+    }
+});
+authoring.command("revise").argument("<sessionId>").argument("<scriptFile>").requiredOption("--source <source>").option("--base-revision-id <id>").requiredOption("--idempotency-key <key>").action(async function (sessionId, scriptFile, options) { const ctx = context(this); const parsed = await loadScript(scriptFile); const result = await withFreshSession(ctx, sessionId, (client) => client.authoring.createRevision(sessionId, parsed.script, options.source, options.idempotencyKey, options.baseRevisionId)); emit(ctx, result, `Authoring Revision ${result.id} created`); });
+authoring.command("revision").argument("<sessionId>").argument("<revisionId>").action(async function (sessionId, revisionId) { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.authoring.getRevision(sessionId, revisionId)); });
+authoring.command("observe").argument("<sessionId>").action(async function (sessionId) { const ctx = context(this); emit(ctx, await withFreshSession(ctx, sessionId, (client) => client.authoring.observe(sessionId))); });
+authoring.command("draft-save").argument("<sessionId>").argument("<scriptFile>").requiredOption("--next-step-index <number>").option("--workspace <dir>", undefined, ".").option("--execution-mode <mode>").option("--attempt-id <id>").option("--attempt-status <status>").action(async function (sessionId, scriptFile, options) { const ctx = context(this); const content = (await loadScript(scriptFile)).content; const result = await new AuthoringDraftStore(options.workspace).checkpoint(sessionId, content, { nextStepIndex: Number(options.nextStepIndex), executionMode: options.executionMode, attemptId: options.attemptId, attemptStatus: options.attemptStatus }); emit(ctx, result, `Local Authoring checkpoint ${result.checkpoint} saved`); });
+authoring.command("draft-resume").argument("<sessionId>").option("--workspace <dir>", undefined, ".").action(async function (sessionId, options) { const ctx = context(this); emit(ctx, await new AuthoringDraftStore(options.workspace).resume(sessionId)); });
+authoring.command("drafts").option("--workspace <dir>", undefined, ".").action(async function (options) { const ctx = context(this); emit(ctx, await new AuthoringDraftStore(options.workspace).list()); });
+authoring.command("draft-step").argument("<sessionId>").argument("<scriptFile>").argument("<stepIndex>").requiredOption("--idempotency-key <key>").option("--workspace <dir>", undefined, ".").option("--execution-mode <mode>").action(async function (sessionId, scriptFile, stepIndex, options) { const ctx = context(this); const parsed = await loadScript(scriptFile); const store = new AuthoringDraftStore(options.workspace); await store.checkpoint(sessionId, parsed.content, { nextStepIndex: Number(stepIndex), executionMode: options.executionMode, attemptStatus: "READY" }); const attempt = await withFreshSession(ctx, sessionId, (client) => client.authoring.executeDraftStep(sessionId, parsed.script, Number(stepIndex), options.idempotencyKey)); const checkpoint = await store.checkpoint(sessionId, parsed.content, { nextStepIndex: attempt.status === "PASSED" ? Number(stepIndex) + 1 : Number(stepIndex), executionMode: options.executionMode, attemptId: attempt.id, attemptStatus: attempt.status }); emit(ctx, { ...attempt, local_checkpoint: checkpoint }, `Draft Step Attempt ${attempt.id} status=${attempt.status}`); });
+authoring.command("attempt").argument("<attemptId>").action(async function (attemptId) { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.authoring.getAttempt(attemptId)); });
+authoring.command("complete").argument("<sessionId>").argument("<revisionId>").requiredOption("--idempotency-key <key>").action(async function (sessionId, revisionId, options) { const ctx = context(this); emit(ctx, await withFreshSession(ctx, sessionId, (client) => client.authoring.complete(sessionId, revisionId, options.idempotencyKey))); });
+authoring.command("cancel").argument("<sessionId>").requiredOption("--idempotency-key <key>").action(async function (sessionId, options) { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.authoring.cancel(sessionId, options.idempotencyKey)); });
+const device = program.command("device").description("Direct structured control of one Android device");
+device.command("list").option("--device-id <id>").option("--keyword <text>").option("--platform <name>").option("--brand <name>").option("--model <name>").option("--os-version <version>").option("--resolution <value>").option("--min-sdk-version <version>").option("--available").option("--page <number>").option("--page-size <number>").action(async function (options) { const ctx = context(this); const query = { device_id: options.deviceId, keyword: options.keyword, platform: options.platform, brand: options.brand, model: options.model, os_version: options.osVersion, resolution: options.resolution, min_sdk_version: options.minSdkVersion, ...(options.available ? { available: true } : {}), page: options.page, page_size: options.pageSize }; emit(ctx, await (await authenticatedClient(ctx)).client.authoring.listDevices(query)); });
+device.command("acquire").requiredOption("--device-id <id>").requiredOption("--idempotency-key <key>").action(async function (options) { const ctx = context(this); const result = await (await authenticatedClient(ctx)).client.action.acquireDevice(options.deviceId, options.idempotencyKey); emit(ctx, result, `Device Session ${result.session.id} acquired${billingText(result)}`); });
+device.command("renew").argument("<sessionId>").action(async function (sessionId) { const ctx = context(this); const result = await (await authenticatedClient(ctx)).client.action.renewSession(sessionId); emit(ctx, result, `Device Session ${result.id} renewed until ${result.expires_at}${billingText(result)}`); });
+device.command("keepalive").argument("<sessionId>").option("--poll-interval <seconds>", undefined, "30").action(async function (sessionId, options) {
+    const ctx = context(this);
+    const { client } = await authenticatedClient(ctx);
+    const manager = new SessionLeaseManager(client.action, { onEvent: (event) => emit(ctx, event, event.type === "renewed" ? `Device Session ${event.session_id} renewed until ${event.expires_at ?? "unknown"}` : undefined) });
+    const deregister = onInterrupt(async () => { manager.unregister(sessionId); });
+    try {
+        await manager.keepAlive(sessionId, { pollMs: Number(options.pollInterval) * 1000 });
+        emit(ctx, { session_id: sessionId, status: "TERMINAL", lease: manager.getLease(sessionId) ?? null }, `Device Session ${sessionId} is terminal`);
+    }
+    finally {
+        deregister();
+        manager.unregister(sessionId);
+    }
+});
+device.command("observe").argument("<sessionId>").action(async function (sessionId) { const ctx = context(this); emit(ctx, await withFreshActionSession(ctx, sessionId, (client) => client.action.observe(sessionId))); });
+device.command("action").argument("<sessionId>").requiredOption("--request-json <json>").option("--screen-id <id>").requiredOption("--idempotency-key <key>").action(async function (sessionId, options) { const ctx = context(this); const actionRequest = buildDeviceActionRequest({ screenId: options.screenId, requestJson: options.requestJson }); const result = await withFreshActionSession(ctx, sessionId, (client) => client.action.executeAction(sessionId, actionRequest, options.idempotencyKey)); emit(ctx, result, `Device Action ${result.action?.action} status=${result.status}${billingText(result)}`); });
+device.command("release").argument("<sessionId>").requiredOption("--idempotency-key <key>").action(async function (sessionId, options) { const ctx = context(this); emit(ctx, await (await authenticatedClient(ctx)).client.action.release(sessionId, options.idempotencyKey)); });
+const targets = program.command("targets");
+targets.command("list").action(async function () { const ctx = context(this); const project = await loadProjectConfig(ctx.projectConfig); emit(ctx, { schema_version: PROJECT_SCHEMA_VERSION, config_path: project.path, default_target: project.defaultTarget, targets: project.listTargets().map((item) => ({ name: item.name, target_hash: item.targetHash, target: item.definition, default: item.name === project.defaultTarget })) }); });
+targets.command("show").argument("<name>").action(async function (name) { const ctx = context(this); const project = await loadProjectConfig(ctx.projectConfig); const item = project.resolveTarget(name); emit(ctx, { schema_version: PROJECT_SCHEMA_VERSION, config_path: project.path, name: item.name, target_hash: item.targetHash, target: item.definition, default: name === project.defaultTarget }); });
+targets.command("validate").argument("[name]").action(async function (name) { const ctx = context(this); const project = await loadProjectConfig(ctx.projectConfig); const selected = name ? [project.resolveTarget(name)] : project.listTargets(); emit(ctx, { valid: true, schema_version: PROJECT_SCHEMA_VERSION, config_path: project.path, targets: selected.map((item) => ({ name: item.name, target_hash: item.targetHash, target: item.definition })) }, `${project.path}: valid (${selected.length} Targets)`); });
+targets.command("preview").argument("<name>").action(async function (name) { const ctx = context(this); const project = await loadProjectConfig(ctx.projectConfig); const item = project.resolveTarget(name); const { profile, client } = await authenticatedClient(ctx); requireProjectCi(profile, "Target preview"); emit(ctx, await client.previewTarget({ schema_version: "xagent-target-preview/v1", target_name: item.name, target_hash: item.targetHash, target: item.definition })); });
+const apps = program.command("apps");
+apps.command("list").option("--keyword <text>").option("--app-name <name>").option("--package-name <name>").option("--page <number>").option("--page-size <number>").action(async function (options) { const ctx = context(this); const query = { keyword: options.keyword, app_name: options.appName, package_name: options.packageName, page: options.page, page_size: options.pageSize }; const result = await (await authenticatedClient(ctx)).client.listApps(query); emit(ctx, result, `${result.total} application package(s)`); });
+apps.command("show").argument("<packageId>").action(async function (packageId) { const ctx = context(this); const parsed = Number(packageId); if (!Number.isInteger(parsed) || parsed < 1)
+    throw new CliError("invalid_request", "package-id must be a positive integer"); const result = await (await authenticatedClient(ctx)).client.getApp(parsed); emit(ctx, result, `${result.package_id}: ${result.package_name}`); });
+apps.command("upload").argument("<apkFile>").option("--upload-timeout <seconds>", undefined, "900").action(async function (apkFile, options) { const ctx = context(this); if (!apkFile.toLowerCase().endsWith(".apk"))
+    throw new CliError("invalid_request", "apps upload requires an APK file"); const { client } = await authenticatedClient(ctx, Number(options.uploadTimeout) * 1000); const result = await client.uploadApp(apkFile, (done, total) => (ctx.json ? process.stderr : process.stdout).write(`APK 分片上传：${done}/${total}\n`)); emit(ctx, result, `Uploaded ${apkFile}: package_id=${result.package_id} package=${result.app?.package_name}`); });
+apps.command("release").argument("<appUploadId>").action(async function (id) { const ctx = context(this); const { client } = await authenticatedClient(ctx); const result = await client.releaseApp(id); emit(ctx, result, `App upload ${id} status=${result.status}`); });
+program.command("run")
+    .argument("<scriptFile>")
+    .option("--package-id <id>")
+    .option("--app-upload-id <id>")
+    .option("--apk <path>")
+    .option("--device-id <id>")
+    .option("--target <name>")
+    .option("--idempotency-key <key>")
+    .option("--var <assignment>", "Runtime variable NAME=VALUE", (value, previous) => [...previous, value], [])
+    .option("--timeout-ms <milliseconds>", undefined, "600000")
+    .option("--wait")
+    .option("--wait-timeout <seconds>", undefined, "900")
+    .option("--upload-timeout <seconds>", undefined, "900")
+    .action(async function (scriptFile, options) {
+    const ctx = context(this);
+    const parsed = await loadScript(scriptFile);
+    const supplied = [options.packageId, options.appUploadId, options.apk].filter((item) => item !== undefined).length;
+    if (supplied > 1)
+        throw new CliError("invalid_request", "--package-id, --app-upload-id and --apk are mutually exclusive");
+    const script = structuredClone(parsed.script);
+    if (options.appUploadId || options.apk)
+        delete script.package_id;
+    const packageId = options.packageId ? Number(options.packageId) : script.package_id;
+    if (packageId !== undefined && (!Number.isInteger(Number(packageId)) || Number(packageId) < 1))
+        throw new CliError("invalid_request", "--package-id must be a positive integer");
+    const hasInstall = script.steps.some((step) => step.action === "install");
+    if (packageId === undefined && !options.appUploadId && !options.apk && hasInstall)
+        throw new CliError("invalid_request", "package_id or --app-upload-id is required when the script contains install");
+    const profile = await selectedProfile(ctx);
+    let request;
+    if (profile.data.expected_token_type === "personal") {
+        if (options.target)
+            throw new CliError("token_type_mismatch", "personal Profile cannot use --target", 3);
+        if (options.apk && !String(options.apk).toLowerCase().endsWith(".apk"))
+            throw new CliError("invalid_request", "--apk requires an APK file");
+        if (!options.deviceId)
+            throw new CliError("invalid_request", "--device-id is required for a personal Profile");
+        if (options.idempotencyKey)
+            throw new CliError("invalid_request", "--idempotency-key is only valid for a project_ci Profile");
+        request = { schema_version: "xagent-run-create/v1", script, device_id: options.deviceId, timeout_ms: Number(options.timeoutMs), source_hash: parsed.sourceHash };
+    }
+    else {
+        if (options.apk)
+            throw new CliError("token_type_mismatch", "project_ci Profile must use apps upload and --app-upload-id", 3);
+        if (options.deviceId)
+            throw new CliError("token_type_mismatch", "project_ci Profile cannot use --device-id", 3);
+        if (!String(options.idempotencyKey ?? "").trim())
+            throw new CliError("invalid_request", "--idempotency-key is required for a project_ci Run");
+        const target = (await loadProjectConfig(ctx.projectConfig)).resolveTarget(options.target);
+        request = { schema_version: "xagent-run-create/v2", script, target_name: target.name, target_hash: target.targetHash, target: target.definition, timeout_ms: Number(options.timeoutMs), source_hash: parsed.sourceHash };
+    }
+    const variables = parseVariables(options.var ?? []);
+    if (Object.keys(variables).length)
+        request.variables = variables;
+    const { client } = await authenticatedClient(ctx, Number(options.uploadTimeout) * 1000);
+    let uploadedId;
+    let primaryError;
+    let run;
+    // Ctrl+C would otherwise skip the finally below and leave both the APK
+    // and a Run occupying a device allocated until each expires on its own.
+    let createdRunId;
+    const waiting = new AbortController();
+    const releaseOnInterrupt = onInterrupt(async () => {
+        // Stop the poll loop first so it cannot keep issuing requests while we release.
+        waiting.abort();
+        // Both releases are independent: a failed cancel must not skip the APK release.
+        const report = (what, error) => process.stderr.write(`${what} failed: ${error instanceof Error ? error.message : String(error)}\n`);
+        if (createdRunId) {
+            try {
+                await client.cancelRun(createdRunId);
+            }
+            catch (error) {
+                report(`Cancel run ${createdRunId}`, error);
+            }
+        }
+        if (uploadedId) {
+            try {
+                await client.releaseApp(uploadedId);
+            }
+            catch (error) {
+                report(`Release app upload ${uploadedId}`, error);
+            }
+        }
+    });
+    try {
+        if (options.apk) {
+            const uploaded = await client.uploadApp(options.apk, (done, total) => (ctx.json ? process.stderr : process.stdout).write(`APK 分片上传：${done}/${total}\n`));
+            uploadedId = String(uploaded.id ?? "");
+            if (!uploadedId)
+                throw new XAgentApiError("invalid_response", "APK upload did not return an upload ID");
+            request.app_upload_id = uploadedId;
+        }
+        else if (packageId !== undefined)
+            request.package_id = Number(packageId);
+        if (options.appUploadId)
+            request.app_upload_id = options.appUploadId;
+        run = await client.createRun(request, options.idempotencyKey?.trim());
+        createdRunId = String(run.id ?? "") || undefined;
+        if (options.wait) {
+            run = await client.waitRun(run.id, Number(options.waitTimeout), 2, progressReporter(ctx), waiting.signal);
+            createdRunId = undefined; // reached a terminal state, nothing left to cancel
+        }
+    }
+    catch (error) {
+        primaryError = error;
+        throw error;
+    }
+    finally {
+        if (uploadedId) {
+            const releasing = uploadedId;
+            // Cleared only on success so an interrupt mid-release still retries it.
+            try {
+                await client.releaseApp(releasing);
+                uploadedId = undefined;
+            }
+            catch (error) {
+                if (!primaryError)
+                    throw error;
+            }
+        }
+        releaseOnInterrupt();
+    }
+    emitRun(ctx, run);
+});
+const runs = program.command("runs");
+runs.command("show").argument("<runId>").action(async function (runId) { const ctx = context(this); emitRun(ctx, await (await authenticatedClient(ctx)).client.getRun(runId), false); });
+runs.command("wait").argument("<runId>").option("--timeout <seconds>", undefined, "900").option("--poll-interval <seconds>", undefined, "2").action(async function (runId, options) { const ctx = context(this); const run = await (await authenticatedClient(ctx)).client.waitRun(runId, Number(options.timeout), Number(options.pollInterval), progressReporter(ctx)); emitRun(ctx, run); });
+runs.command("cancel").argument("<runId>").action(async function (runId) { const ctx = context(this); emitRun(ctx, await (await authenticatedClient(ctx)).client.cancelRun(runId), false); });
+program.command("mcp").option("--mode <mode>", `Isolated Tool surface: ${MCP_MODES.join(", ")}`, "action").action(async function (options) { const ctx = context(this); if (!MCP_MODES.includes(options.mode))
+    throw new CliError("invalid_request", `mcp --mode must be one of: ${MCP_MODES.join(", ")}`); await runStdioServer(ctx.profile, ctx.userConfig, undefined, options.mode); });
+export async function runCli(argv = process.argv) {
+    try {
+        await program.parseAsync(argv);
+    }
+    catch (error) {
+        fail(error);
+    }
+}
+function isCliEntryPoint() {
+    if (!process.argv[1])
+        return false;
+    try {
+        return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+    }
+    catch {
+        return false;
+    }
+}
+if (isCliEntryPoint())
+    await runCli();
+//# sourceMappingURL=cli.js.map