@autifyhq/aximo-cli 0.1.0

package/dist/commands/upload/submit.d.ts

@@ -0,0 +1,19 @@
+import type { Envelope, UploadSubmitResult } from "../../types.js";
+import { type ClientDeps } from "../../client.js";
+import { type DryRunResult } from "../../mutate.js";
+export interface UploadSubmitOptions {
+    uploadId?: unknown;
+    dryRun?: unknown;
+}
+export declare function runUploadSubmit(options: UploadSubmitOptions, deps?: ClientDeps): Promise<Envelope<UploadSubmitResult | DryRunResult>>;
+declare const _default: import("citty").CommandDef<{
+    readonly uploadId: {
+        readonly type: "positional";
+        readonly required: true;
+    };
+    readonly "dry-run": {
+        readonly type: "boolean";
+        readonly description: "Validate and show request without calling API";
+    };
+}>;
+export default _default;

package/dist/commands/upload/submit.js

@@ -0,0 +1,36 @@
+import { defineCommand } from "citty";
+import { formatSuccess, printResult, validationError } from "../../output.js";
+import { handleApiError } from "../../errors.js";
+import { request } from "../../client.js";
+import { requireId } from "../../validate.js";
+import { dryRunEnvelope } from "../../mutate.js";
+export async function runUploadSubmit(options, deps) {
+    let uploadId;
+    try {
+        uploadId = requireId("uploadId", options.uploadId);
+    }
+    catch (err) {
+        return validationError(err);
+    }
+    const path = `/api/uploads/${encodeURIComponent(uploadId)}/submit`;
+    if (options.dryRun) {
+        return dryRunEnvelope("POST", path);
+    }
+    try {
+        const res = await request(path, { method: "POST" }, deps ?? {});
+        return formatSuccess(res);
+    }
+    catch (err) {
+        return handleApiError(err);
+    }
+}
+export default defineCommand({
+    meta: { name: "submit", description: "Submit an uploaded file for processing" },
+    args: {
+        uploadId: { type: "positional", required: true },
+        "dry-run": { type: "boolean", description: "Validate and show request without calling API" },
+    },
+    async run({ args }) {
+        printResult(await runUploadSubmit({ uploadId: args.uploadId, dryRun: args["dry-run"] }));
+    },
+});

package/dist/commands/upload/upload.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/commands/upload/upload.test.js

@@ -0,0 +1,133 @@
+import { afterAll, afterEach, beforeAll, describe, expect, it } from "vitest";
+import { server, http, HttpResponse, TEST_BASE_URL } from "../../test-utils.js";
+import { runUploadCreate } from "./create.js";
+import { runUploadList } from "./list.js";
+import { runUploadGet } from "./get.js";
+import { runUploadPut } from "./put.js";
+import { runUploadSubmit } from "./submit.js";
+beforeAll(() => {
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterEach(() => server.resetHandlers());
+afterAll(() => server.close());
+describe("runUploadCreate", () => {
+    it("POSTs and returns presignedUrl", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/uploads`, () => HttpResponse.json({ uploadId: "u1", presignedUrl: "https://s3/...", fileType: "IOS_APP" }, { status: 201 })));
+        const result = await runUploadCreate({ fileName: "app.ipa", platform: "IOS", fileSize: "100" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.uploadId).toBe("u1");
+    });
+    it("rejects missing fileName", async () => {
+        const result = await runUploadCreate({});
+        expect(result.ok).toBe(false);
+    });
+    it("--json replaces body", async () => {
+        let seen;
+        server.use(http.post(`${TEST_BASE_URL}/api/uploads`, async ({ request: req }) => {
+            seen = await req.json();
+            return HttpResponse.json({ uploadId: "u2", presignedUrl: "x", fileType: "IOS_APP" }, { status: 201 });
+        }));
+        const result = await runUploadCreate({ json: '{"fileName":"r.ipa"}' });
+        expect(result.ok).toBe(true);
+        expect(seen).toEqual({ fileName: "r.ipa" });
+    });
+    it("--dry-run skips call", async () => {
+        const result = await runUploadCreate({ fileName: "a.ipa", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.url).toBe(`${TEST_BASE_URL}/api/uploads`);
+        }
+    });
+    it("rejects non-integer fileSize", async () => {
+        const result = await runUploadCreate({ fileName: "a", fileSize: "1.5" });
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("validation_error");
+    });
+});
+describe("runUploadList", () => {
+    it("forwards fileType query", async () => {
+        let seenUrl = "";
+        server.use(http.get(`${TEST_BASE_URL}/api/uploads`, ({ request: req }) => {
+            seenUrl = req.url;
+            return HttpResponse.json({ uploads: [{ id: "u1" }] });
+        }));
+        const result = await runUploadList({ fileType: "ANDROID_APP" });
+        expect(result.ok).toBe(true);
+        expect(seenUrl).toContain("fileType=ANDROID_APP");
+    });
+    it("rejects invalid fileType", async () => {
+        const result = await runUploadList({ fileType: "EXE" });
+        expect(result.ok).toBe(false);
+    });
+});
+describe("runUploadGet", () => {
+    it("fetches by id", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/uploads/u1`, () => HttpResponse.json({ id: "u1", fileName: "app.ipa" })));
+        const result = await runUploadGet("u1");
+        expect(result.ok).toBe(true);
+    });
+    it("maps 404", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/uploads/missing`, () => HttpResponse.json({ error: "Not found" }, { status: 404 })));
+        const result = await runUploadGet("missing");
+        expect(result.ok).toBe(false);
+        if (!result.ok)
+            expect(result.error.code).toBe("not_found");
+    });
+});
+describe("runUploadPut", () => {
+    it("PUTs binary body with octet-stream content-type", async () => {
+        let seenCT = "";
+        let seenMethod = "";
+        let body = null;
+        server.use(http.put(`${TEST_BASE_URL}/api/uploads/u1`, async ({ request: req }) => {
+            seenCT = req.headers.get("content-type") ?? "";
+            seenMethod = req.method;
+            body = await req.arrayBuffer();
+            return HttpResponse.json({ success: true });
+        }));
+        const result = await runUploadPut({ uploadId: "u1", bytes: new Uint8Array([9, 9]) });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.success).toBe(true);
+        expect(seenMethod).toBe("PUT");
+        expect(seenCT).toContain("application/octet-stream");
+        expect(body).not.toBeNull();
+        expect(new Uint8Array(body)).toEqual(new Uint8Array([9, 9]));
+    });
+    it("rejects missing bytes", async () => {
+        const result = await runUploadPut({ uploadId: "u1" });
+        expect(result.ok).toBe(false);
+    });
+    it("--dry-run returns request without bytes", async () => {
+        const result = await runUploadPut({ uploadId: "u1", dryRun: true });
+        expect(result.ok).toBe(true);
+        if (result.ok && "dryRun" in result.data) {
+            expect(result.data.method).toBe("PUT");
+        }
+    });
+    it("rejects uploadId with forbidden chars", async () => {
+        const result = await runUploadPut({ uploadId: "u1?x=1", bytes: new Uint8Array([1]) });
+        expect(result.ok).toBe(false);
+    });
+});
+describe("runUploadSubmit", () => {
+    it("POSTs submit and returns workflowId", async () => {
+        server.use(http.post(`${TEST_BASE_URL}/api/uploads/u1/submit`, () => HttpResponse.json({ success: true, workflowId: "w1" }, { status: 202 })));
+        const result = await runUploadSubmit({ uploadId: "u1" });
+        expect(result.ok).toBe(true);
+        if (result.ok && !("dryRun" in result.data))
+            expect(result.data.workflowId).toBe("w1");
+    });
+    it("rejects empty id", async () => {
+        const result = await runUploadSubmit({ uploadId: "" });
+        expect(result.ok).toBe(false);
+    });
+    it("submit --dry-run", async () => {
+        const result = await runUploadSubmit({ uploadId: "u1", dryRun: true });
+        expect(result.ok).toBe(true);
+    });
+});

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+export interface CliConfig {
+    apiKey?: string;
+    baseUrl?: string;
+}
+export declare function getConfigPath(): string;
+export declare function loadConfig(): CliConfig;
+export declare function saveConfig(config: CliConfig): void;

package/dist/config.js

@@ -0,0 +1,36 @@
+import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { getAximoDir } from "./commands/device/paths.js";
+export function getConfigPath() {
+    return join(getAximoDir(), "config.json");
+}
+export function loadConfig() {
+    const path = getConfigPath();
+    if (!existsSync(path))
+        return {};
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        const result = {};
+        const apiKey = parsed["apiKey"];
+        const baseUrl = parsed["baseUrl"];
+        if (typeof apiKey === "string" && apiKey.length > 0)
+            result.apiKey = apiKey;
+        if (typeof baseUrl === "string" && baseUrl.length > 0)
+            result.baseUrl = baseUrl;
+        return result;
+    }
+    catch {
+        return {};
+    }
+}
+export function saveConfig(config) {
+    mkdirSync(getAximoDir(), { recursive: true });
+    const path = getConfigPath();
+    writeFileSync(path, JSON.stringify(config, null, 2), { mode: 0o600 });
+    try {
+        chmodSync(path, 0o600);
+    }
+    catch {
+        // chmod may fail on Windows, file-level ACLs apply instead
+    }
+}

package/dist/desktop-server/agent-sync.d.ts

@@ -0,0 +1,19 @@
+import { type ClientDeps } from "../client.js";
+export interface AgentAssetInfo {
+    sha256: string;
+    size: number;
+}
+export interface AgentManifest {
+    manifestVersion: 2;
+    version: string;
+    script: AgentAssetInfo;
+    requirements: AgentAssetInfo;
+}
+export interface EnsureAgentResult {
+    scriptPath: string;
+    requirementsPath: string;
+    changed: boolean;
+    version: string;
+}
+export declare function ensureAgent(deps?: ClientDeps): Promise<EnsureAgentResult>;
+export declare function readCachedManifest(): AgentManifest | null;

package/dist/desktop-server/agent-sync.js

@@ -0,0 +1,141 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { request, requestBuffer } from "../client.js";
+import { getAgentDir, getAgentManifestPath, getAgentRequirementsPath, getAgentScriptPath, } from "../commands/device/paths.js";
+const MANIFEST_PATH = "/api/devices/agent/manifest";
+const SCRIPT_ASSET_PATH = "/api/devices/agent/remote.py";
+const REQUIREMENTS_ASSET_PATH = "/api/devices/agent/requirements.txt";
+function hashBuffer(buffer) {
+    return createHash("sha256").update(buffer).digest("hex");
+}
+function readLocalManifest() {
+    const path = getAgentManifestPath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(path, "utf-8"));
+        if (!parsed || typeof parsed !== "object")
+            return null;
+        const manifest = parsed;
+        if (manifest.manifestVersion === 2 &&
+            typeof manifest.version === "string" &&
+            manifest.script?.sha256 &&
+            manifest.requirements?.sha256) {
+            return manifest;
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+function writeManifest(manifest) {
+    writeFileSync(getAgentManifestPath(), JSON.stringify(manifest, null, 2), {
+        mode: 0o644,
+    });
+}
+function localFilesMatch(server) {
+    const scriptPath = getAgentScriptPath();
+    const requirementsPath = getAgentRequirementsPath();
+    if (!existsSync(scriptPath) || !existsSync(requirementsPath))
+        return false;
+    try {
+        const scriptHash = hashBuffer(readFileSync(scriptPath));
+        if (scriptHash !== server.script.sha256)
+            return false;
+        const reqHash = hashBuffer(readFileSync(requirementsPath));
+        if (reqHash !== server.requirements.sha256)
+            return false;
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function validateManifest(raw) {
+    if (!raw || typeof raw !== "object") {
+        throw new Error("Invalid agent manifest: response is not an object");
+    }
+    const m = raw;
+    if (m.manifestVersion !== 2) {
+        throw new Error(`Unsupported agent manifest version: ${m.manifestVersion}. Update aximo-cli to the latest version.`);
+    }
+    if (typeof m.version !== "string" ||
+        !m.script ||
+        typeof m.script.sha256 !== "string" ||
+        typeof m.script.size !== "number" ||
+        !m.requirements ||
+        typeof m.requirements.sha256 !== "string" ||
+        typeof m.requirements.size !== "number") {
+        throw new Error("Invalid agent manifest: missing or malformed fields");
+    }
+    return m;
+}
+async function fetchAsset(path, expected, deps) {
+    const buffer = await requestBuffer(path, deps);
+    if (buffer.byteLength !== expected.size) {
+        throw new Error(`Agent asset ${path} size mismatch: expected ${expected.size} bytes, got ${buffer.byteLength}`);
+    }
+    const actual = hashBuffer(buffer);
+    if (actual !== expected.sha256) {
+        throw new Error(`Agent asset ${path} sha256 mismatch: expected ${expected.sha256}, got ${actual}`);
+    }
+    return buffer;
+}
+function atomicWrite(finalPath, stagingPath, buffer) {
+    writeFileSync(stagingPath, buffer, { mode: 0o644 });
+    // Windows' renameSync fails when the destination already exists. Remove it
+    // first so agent updates work on Windows (primary BYOD target).
+    if (existsSync(finalPath)) {
+        rmSync(finalPath, { force: true });
+    }
+    renameSync(stagingPath, finalPath);
+}
+export async function ensureAgent(deps) {
+    const agentDir = getAgentDir();
+    mkdirSync(agentDir, { recursive: true });
+    let server;
+    try {
+        const raw = await request(MANIFEST_PATH, {}, deps ?? {});
+        server = validateManifest(raw);
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        throw new Error(`Failed to fetch agent manifest: ${message}. Check AXIMO_BASE_URL and AXIMO_API_KEY.`);
+    }
+    const local = readLocalManifest();
+    if (local?.version === server.version && localFilesMatch(server)) {
+        return {
+            scriptPath: getAgentScriptPath(),
+            requirementsPath: getAgentRequirementsPath(),
+            changed: false,
+            version: server.version,
+        };
+    }
+    const [scriptBuffer, requirementsBuffer] = await Promise.all([
+        fetchAsset(SCRIPT_ASSET_PATH, server.script, deps ?? {}),
+        fetchAsset(REQUIREMENTS_ASSET_PATH, server.requirements, deps ?? {}),
+    ]);
+    const scriptStaging = join(agentDir, "remote.py.tmp");
+    const requirementsStaging = join(agentDir, "requirements.txt.tmp");
+    try {
+        atomicWrite(getAgentScriptPath(), scriptStaging, scriptBuffer);
+        atomicWrite(getAgentRequirementsPath(), requirementsStaging, requirementsBuffer);
+        writeManifest(server);
+    }
+    catch (err) {
+        rmSync(scriptStaging, { force: true });
+        rmSync(requirementsStaging, { force: true });
+        throw err;
+    }
+    return {
+        scriptPath: getAgentScriptPath(),
+        requirementsPath: getAgentRequirementsPath(),
+        changed: true,
+        version: server.version,
+    };
+}
+export function readCachedManifest() {
+    return readLocalManifest();
+}

package/dist/desktop-server/agent-sync.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/desktop-server/agent-sync.test.js

@@ -0,0 +1,130 @@
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, afterEach, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { getAgentManifestPath, getAgentRequirementsPath, getAgentScriptPath, } from "../commands/device/paths.js";
+import { HttpResponse, TEST_BASE_URL, http, server } from "../test-utils.js";
+import { ensureAgent, readCachedManifest } from "./agent-sync.js";
+let tempHome;
+function sha256(buffer) {
+    return createHash("sha256").update(buffer).digest("hex");
+}
+const SCRIPT = 'print("hello")\n';
+const REQUIREMENTS = "requests==2.31.0\n";
+function buildManifest() {
+    const scriptSha = sha256(SCRIPT);
+    const requirementsSha = sha256(REQUIREMENTS);
+    return {
+        manifestVersion: 2,
+        version: sha256(`${scriptSha}:${requirementsSha}`).slice(0, 8),
+        script: { sha256: scriptSha, size: Buffer.byteLength(SCRIPT) },
+        requirements: { sha256: requirementsSha, size: Buffer.byteLength(REQUIREMENTS) },
+    };
+}
+function mockAgentEndpoints(script = SCRIPT, requirements = REQUIREMENTS) {
+    const scriptSha = sha256(script);
+    const requirementsSha = sha256(requirements);
+    const manifest = {
+        manifestVersion: 2,
+        version: sha256(`${scriptSha}:${requirementsSha}`).slice(0, 8),
+        script: { sha256: scriptSha, size: Buffer.byteLength(script) },
+        requirements: { sha256: requirementsSha, size: Buffer.byteLength(requirements) },
+    };
+    server.use(http.get(`${TEST_BASE_URL}/api/devices/agent/manifest`, () => HttpResponse.json(manifest)), http.get(`${TEST_BASE_URL}/api/devices/agent/remote.py`, () => new HttpResponse(script, { headers: { "Content-Type": "text/x-python" } })), http.get(`${TEST_BASE_URL}/api/devices/agent/requirements.txt`, () => new HttpResponse(requirements, { headers: { "Content-Type": "text/plain" } })));
+    return manifest;
+}
+beforeAll(() => {
+    tempHome = mkdtempSync(join(tmpdir(), "aximo-agent-"));
+    process.env["AXIMO_HOME"] = tempHome;
+    process.env["AXIMO_API_KEY"] = "test-key";
+    process.env["AXIMO_BASE_URL"] = TEST_BASE_URL;
+    server.listen();
+});
+afterAll(() => {
+    delete process.env["AXIMO_HOME"];
+    server.close();
+    rmSync(tempHome, { recursive: true, force: true });
+});
+beforeEach(() => {
+    rmSync(tempHome, { recursive: true, force: true });
+    mkdirSync(tempHome, { recursive: true });
+});
+afterEach(() => server.resetHandlers());
+describe("ensureAgent", () => {
+    it("downloads both files on first run and writes manifest", async () => {
+        const manifest = mockAgentEndpoints();
+        const result = await ensureAgent();
+        expect(result.changed).toBe(true);
+        expect(result.version).toBe(manifest.version);
+        expect(readFileSync(getAgentScriptPath(), "utf-8")).toBe(SCRIPT);
+        expect(readFileSync(getAgentRequirementsPath(), "utf-8")).toBe(REQUIREMENTS);
+        const savedManifest = JSON.parse(readFileSync(getAgentManifestPath(), "utf-8"));
+        expect(savedManifest.version).toBe(manifest.version);
+    });
+    it("skips download when local manifest and files match server", async () => {
+        mockAgentEndpoints();
+        await ensureAgent();
+        let scriptHits = 0;
+        server.use(http.get(`${TEST_BASE_URL}/api/devices/agent/remote.py`, () => {
+            scriptHits++;
+            return new HttpResponse(SCRIPT);
+        }));
+        const second = await ensureAgent();
+        expect(second.changed).toBe(false);
+        expect(scriptHits).toBe(0);
+    });
+    it("refetches when server version differs", async () => {
+        mockAgentEndpoints();
+        await ensureAgent();
+        const updatedScript = 'print("hello v2")\n';
+        const updatedManifest = mockAgentEndpoints(updatedScript);
+        const result = await ensureAgent();
+        expect(result.changed).toBe(true);
+        expect(result.version).toBe(updatedManifest.version);
+        expect(readFileSync(getAgentScriptPath(), "utf-8")).toBe(updatedScript);
+    });
+    it("rejects a downloaded asset whose sha256 doesn't match manifest", async () => {
+        const manifest = buildManifest();
+        // Same length as SCRIPT ('print("hello")\n' = 15 bytes) to trip the sha check, not the size check
+        const tampered = 'print("HELLO")\n';
+        expect(tampered.length).toBe(SCRIPT.length);
+        server.use(http.get(`${TEST_BASE_URL}/api/devices/agent/manifest`, () => HttpResponse.json(manifest)), http.get(`${TEST_BASE_URL}/api/devices/agent/remote.py`, () => new HttpResponse(tampered)), http.get(`${TEST_BASE_URL}/api/devices/agent/requirements.txt`, () => HttpResponse.text(REQUIREMENTS)));
+        await expect(ensureAgent()).rejects.toThrow(/sha256 mismatch/);
+        expect(existsSync(getAgentScriptPath())).toBe(false);
+        expect(existsSync(getAgentManifestPath())).toBe(false);
+    });
+    it("rejects unsupported manifest version", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/devices/agent/manifest`, () => HttpResponse.json({ manifestVersion: 99, version: "abc", script: {}, requirements: {} })));
+        await expect(ensureAgent()).rejects.toThrow(/manifestVersion|Unsupported/);
+    });
+    it("wraps manifest fetch failure with an actionable message", async () => {
+        server.use(http.get(`${TEST_BASE_URL}/api/devices/agent/manifest`, () => HttpResponse.json({ error: "nope" }, { status: 500 })));
+        await expect(ensureAgent()).rejects.toThrow(/Failed to fetch agent manifest/);
+    });
+    it("refetches if local files were deleted, even when manifest matches", async () => {
+        mockAgentEndpoints();
+        await ensureAgent();
+        rmSync(getAgentScriptPath());
+        const result = await ensureAgent();
+        expect(result.changed).toBe(true);
+        expect(existsSync(getAgentScriptPath())).toBe(true);
+    });
+});
+describe("readCachedManifest", () => {
+    it("returns null when manifest is missing", () => {
+        expect(readCachedManifest()).toBeNull();
+    });
+    it("returns null when manifest is unparseable", () => {
+        mkdirSync(join(tempHome, "agent"), { recursive: true });
+        writeFileSync(getAgentManifestPath(), "not json");
+        expect(readCachedManifest()).toBeNull();
+    });
+    it("returns the parsed manifest when valid", async () => {
+        const expected = mockAgentEndpoints();
+        await ensureAgent();
+        const cached = readCachedManifest();
+        expect(cached?.version).toBe(expected.version);
+        expect(cached?.manifestVersion).toBe(2);
+    });
+});

package/dist/desktop-server/setup.d.ts

@@ -0,0 +1,19 @@
+import { type ChildProcess } from "node:child_process";
+import type { ClientDeps } from "../client.js";
+export declare const PYTHON_RELEASE = "20260414";
+export declare const PYTHON_VERSION = "3.12.13";
+export declare function installedPythonTag(): string;
+export interface PythonReadyResult {
+    pythonPath: string;
+    scriptPath: string;
+    agentVersion: string;
+    agentChanged: boolean;
+}
+export declare function ensurePythonReady(deps?: ClientDeps): Promise<PythonReadyResult>;
+interface RemoteOptions {
+    relayUrl: string;
+    deviceToken: string;
+    deviceName: string;
+}
+export declare function startDesktopRemote(pythonPath: string, scriptPath: string, options: RemoteOptions): ChildProcess;
+export {};