@abitat_reece/cli 0.1.0

package/README.md

@@ -0,0 +1,30 @@
+# Abitat CLI
+
+`abitat` connects a Mac host to the hosted Abitat Workspace control plane so an iPhone can control Codex off-network. The CLI installs `@abitat_reece/host-daemon` as a dependency and launches it directly.
+
+## Install
+
+```sh
+brew tap Abitat/abitat
+brew install abitat
+```
+
+If the formula is accepted into Homebrew core, this becomes:
+
+```sh
+brew install abitat
+```
+
+The npm package is also available:
+
+```sh
+npm install -g @abitat_reece/cli
+```
+
+## Use
+
+```sh
+abitat iphone
+```
+
+The command opens `https://workspace.abitat.io` for login if needed, registers the Mac to the signed-in account, starts the Codex app server and packaged Abitat host daemon, then opens the dashboard for iPhone pairing.

package/dist/auth.js

@@ -0,0 +1,118 @@
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+export function defaultApiUrl(env) {
+    return env.ABITAT_API_URL ?? "https://workspace.abitat.io";
+}
+export function sessionConfigPath(homeDir) {
+    return join(homeDir, "Library", "Application Support", "Abitat", "config.json");
+}
+export async function saveCliSession(session, configPath) {
+    await mkdir(dirname(configPath), { recursive: true });
+    await writeFile(configPath, `${JSON.stringify(session, null, 2)}\n`, "utf8");
+}
+export async function loadCliSession(configPath) {
+    const raw = await readFile(configPath, "utf8").catch((error) => {
+        if (isNotFoundError(error)) {
+            return null;
+        }
+        throw error;
+    });
+    if (!raw) {
+        return null;
+    }
+    const parsed = JSON.parse(raw);
+    if (typeof parsed.apiUrl !== "string" ||
+        typeof parsed.cliToken !== "string" ||
+        typeof parsed.userId !== "string") {
+        return null;
+    }
+    return {
+        apiUrl: parsed.apiUrl,
+        cliToken: parsed.cliToken,
+        userId: parsed.userId
+    };
+}
+export async function deleteCliSession(configPath) {
+    await rm(configPath, { force: true });
+}
+export async function runLoginCommand(input) {
+    const fetchFn = input.fetchFn ?? fetch;
+    const start = await startDeviceLogin(input.apiUrl, fetchFn);
+    input.openUrl(new URL(start.verificationPath, input.apiUrl).toString());
+    const maxPolls = input.maxPolls ?? 120;
+    const pollIntervalMs = input.pollIntervalMs ?? 1000;
+    for (let attempt = 0; attempt < maxPolls; attempt += 1) {
+        const poll = await pollDeviceLogin(input.apiUrl, start.deviceLoginId, fetchFn);
+        if (poll.status === "approved") {
+            const session = {
+                apiUrl: input.apiUrl,
+                cliToken: poll.cliToken,
+                userId: poll.userId
+            };
+            await saveCliSession(session, input.configPath);
+            return session;
+        }
+        if (pollIntervalMs > 0) {
+            await delay(pollIntervalMs);
+        }
+    }
+    throw new Error("Timed out waiting for browser login approval");
+}
+async function startDeviceLogin(apiUrl, fetchFn) {
+    const response = await fetchFn(`${trimTrailingSlash(apiUrl)}/api/cli/device-login/start`, {
+        method: "POST"
+    });
+    if (!response.ok) {
+        throw new Error(`Unable to start CLI login (${response.status})`);
+    }
+    return parseStartResponse(await response.json());
+}
+async function pollDeviceLogin(apiUrl, deviceLoginId, fetchFn) {
+    const response = await fetchFn(`${trimTrailingSlash(apiUrl)}/api/cli/device-login/poll`, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify({ deviceLoginId })
+    });
+    if (!response.ok) {
+        throw new Error(`Unable to poll CLI login (${response.status})`);
+    }
+    return parsePollResponse(await response.json());
+}
+function parseStartResponse(value) {
+    const candidate = value;
+    if (typeof candidate.code !== "string" ||
+        typeof candidate.deviceLoginId !== "string" ||
+        typeof candidate.expiresAt !== "string" ||
+        typeof candidate.verificationPath !== "string") {
+        throw new Error("CLI login start response was invalid");
+    }
+    return {
+        code: candidate.code,
+        deviceLoginId: candidate.deviceLoginId,
+        expiresAt: candidate.expiresAt,
+        verificationPath: candidate.verificationPath
+    };
+}
+function parsePollResponse(value) {
+    const candidate = value;
+    if (candidate.status === "pending") {
+        return { status: "pending" };
+    }
+    if (candidate.status === "approved" &&
+        typeof candidate.cliToken === "string" &&
+        typeof candidate.userId === "string") {
+        return {
+            status: "approved",
+            cliToken: candidate.cliToken,
+            userId: candidate.userId
+        };
+    }
+    throw new Error("CLI login poll response was invalid");
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/u, "");
+}
+function isNotFoundError(error) {
+    return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}

package/dist/index.js

@@ -0,0 +1,127 @@
+#!/usr/bin/env node
+import { spawn } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { homedir, hostname } from "node:os";
+import { resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defaultApiUrl, deleteCliSession, loadCliSession, runLoginCommand, sessionConfigPath } from "./auth.js";
+import { prepareIphoneCommand } from "./iphone.js";
+const DEFAULT_CODEX_APP_SERVER_URL = "ws://127.0.0.1:47777";
+const HOST_DAEMON_CLI_EXPORT = "@abitat_reece/host-daemon/cli";
+export function parseCommand(args) {
+    const command = args[0];
+    if (command === "doctor" || command === "iphone" || command === "login" || command === "logout") {
+        return { command };
+    }
+    return { command: "help" };
+}
+export async function runCli(args, input = {}) {
+    const parsed = parseCommand(args);
+    const env = input.env ?? process.env;
+    const output = input.output ?? console.log;
+    const openUrl = input.openUrl ?? openUrlInBrowser;
+    const homeDir = input.homeDir ?? homedir();
+    const configPath = env.ABITAT_CLI_CONFIG_PATH ?? sessionConfigPath(homeDir);
+    const apiUrl = defaultApiUrl(env);
+    if (parsed.command === "help") {
+        output("Usage: abitat login | abitat iphone | abitat doctor | abitat logout");
+        return 0;
+    }
+    if (parsed.command === "login") {
+        const session = await runLoginCommand({
+            apiUrl,
+            configPath,
+            fetchFn: input.fetchFn,
+            openUrl,
+            pollIntervalMs: input.pollIntervalMs
+        });
+        output(`Logged in to ${session.apiUrl}`);
+        return 0;
+    }
+    if (parsed.command === "logout") {
+        await deleteCliSession(configPath);
+        output("Logged out");
+        return 0;
+    }
+    if (parsed.command === "doctor") {
+        const session = await loadCliSession(configPath);
+        output(session ? `Logged in to ${session.apiUrl}` : "Not logged in. Run `abitat login`.");
+        return 0;
+    }
+    const session = (await loadCliSession(configPath)) ??
+        (await runLoginCommand({
+            apiUrl,
+            configPath,
+            fetchFn: input.fetchFn,
+            openUrl,
+            pollIntervalMs: input.pollIntervalMs
+        }));
+    const result = await prepareIphoneCommand({
+        codexServerUrl: env.CODEX_APP_SERVER_URL ?? DEFAULT_CODEX_APP_SERVER_URL,
+        fetchFn: input.fetchFn,
+        machineName: env.ABITAT_MACHINE_NAME ?? hostname(),
+        platform: input.platform ?? process.platform,
+        session
+    });
+    for (const process of result.startupPlan) {
+        (input.startProcess ?? startProcess)(process);
+    }
+    openUrl(session.apiUrl);
+    output(`Mac host registered as ${result.registration.machineId}`);
+    output(`Open the iPhone app and pair from ${session.apiUrl}`);
+    return 0;
+}
+function startProcess(process) {
+    const resolved = resolveStartupProcess(process);
+    spawn(resolved.command, resolved.args, {
+        env: { ...globalThis.process.env, ...resolved.env },
+        stdio: "inherit"
+    });
+}
+export function resolveStartupProcess(process, options = {}) {
+    if (process.name !== "host-daemon") {
+        return process;
+    }
+    try {
+        const resolvePackageExport = options.resolvePackageExport ?? ((specifier) => import.meta.resolve(specifier));
+        const daemonUrl = resolvePackageExport(HOST_DAEMON_CLI_EXPORT);
+        return {
+            ...process,
+            command: options.nodePath ?? globalThis.process.execPath,
+            args: [fileURLToPath(daemonUrl), ...process.args]
+        };
+    }
+    catch {
+        return process;
+    }
+}
+function openUrlInBrowser(url) {
+    const command = process.platform === "darwin" ? "open" : "xdg-open";
+    const child = spawn(command, [url], {
+        detached: true,
+        stdio: "ignore"
+    });
+    child.unref();
+}
+export function isCliEntrypoint(importMetaUrl, argvPath = process.argv[1]) {
+    if (!argvPath) {
+        return false;
+    }
+    const modulePath = resolve(fileURLToPath(importMetaUrl));
+    const invokedPath = resolve(argvPath);
+    if (modulePath === invokedPath) {
+        return true;
+    }
+    try {
+        return realpathSync(modulePath) === realpathSync(invokedPath);
+    }
+    catch {
+        return false;
+    }
+}
+if (isCliEntrypoint(import.meta.url)) {
+    runCli(process.argv.slice(2)).catch((error) => {
+        console.error(error instanceof Error ? error.message : error);
+        process.exitCode = 1;
+    });
+}

package/dist/iphone.js

@@ -0,0 +1,68 @@
+export function createIphoneStartupPlan(input) {
+    return [
+        {
+            name: "codex-app-server",
+            command: "codex",
+            args: ["app-server", "--listen", input.codexServerUrl, "--analytics-default-enabled"]
+        },
+        {
+            name: "host-daemon",
+            command: "abitat-host",
+            args: ["start"],
+            env: {
+                ABITAT_API_URL: input.apiUrl,
+                ABITAT_HOST_TOKEN: input.hostToken,
+                ABITAT_MACHINE_ID: input.machineId
+            }
+        }
+    ];
+}
+export async function registerHost(input) {
+    const fetchFn = input.fetchFn ?? fetch;
+    const response = await fetchFn(`${trimTrailingSlash(input.apiUrl)}/api/hosts/register`, {
+        method: "POST",
+        headers: {
+            authorization: `Bearer ${input.cliToken}`,
+            "content-type": "application/json"
+        },
+        body: JSON.stringify({
+            machineName: input.machineName,
+            platform: input.platform
+        })
+    });
+    if (!response.ok) {
+        throw new Error(`Unable to register host (${response.status})`);
+    }
+    const body = (await response.json());
+    if (typeof body.machineId !== "string" ||
+        typeof body.workspaceId !== "string" ||
+        typeof body.hostToken !== "string") {
+        throw new Error("Host registration response was invalid");
+    }
+    return {
+        machineId: body.machineId,
+        workspaceId: body.workspaceId,
+        hostToken: body.hostToken
+    };
+}
+export async function prepareIphoneCommand(input) {
+    const registration = await registerHost({
+        apiUrl: input.session.apiUrl,
+        cliToken: input.session.cliToken,
+        fetchFn: input.fetchFn,
+        machineName: input.machineName,
+        platform: input.platform
+    });
+    return {
+        registration,
+        startupPlan: createIphoneStartupPlan({
+            apiUrl: input.session.apiUrl,
+            codexServerUrl: input.codexServerUrl,
+            hostToken: registration.hostToken,
+            machineId: registration.machineId
+        })
+    };
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/u, "");
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@abitat_reece/cli",
+  "private": false,
+  "version": "0.1.0",
+  "description": "Remote Codex control from Mac and iPhone",
+  "type": "module",
+  "bin": {
+    "abitat": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "dependencies": {
+    "@abitat_reece/host-daemon": "0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "25.6.0",
+    "tsx": "4.21.0",
+    "typescript": "6.0.3",
+    "vitest": "4.1.5"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}