@abitat_reece/cli 0.1.5 → 0.1.6

package/README.md

@@ -1,6 +1,6 @@
 # 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.
+`abitat` starts a Mac-local control server so a paired iPhone can control Codex through that Mac. The CLI installs `@abitat_reece/host-daemon` as a dependency and launches it directly; core iPhone control does not require `workspace.abitat.io` or a hosted database.
 
 ## Install
 
@@ -21,10 +21,24 @@ The npm package is also available:
 npm install -g @abitat_reece/cli
 ```
 
+Install the Mac-side tunnel helper:
+
+```sh
+brew install cloudflared
+```
+
 ## 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.
+The command starts the packaged host daemon in local-control mode, starts a Cloudflare Quick Tunnel from the Mac, prints a QR/manual pairing payload with the generated `trycloudflare.com` URL, and bridges iPhone requests to the Mac's Codex app-server. The iPhone only needs the Abitat app.
+
+Other endpoint modes are available when you want them:
+
+```sh
+abitat iphone --transport local
+abitat iphone --transport tailscale
+abitat iphone --transport manual --endpoint https://your-endpoint.example
+```

package/dist/auth.js

@@ -4,7 +4,7 @@ import { setTimeout as delay } from "node:timers/promises";
 const DEFAULT_START_ATTEMPTS = 4;
 const DEFAULT_START_RETRY_DELAY_MS = 1000;
 export function defaultApiUrl(env) {
-    return env.ABITAT_API_URL ?? "https://workspace.abitat.io";
+    return env.ABITAT_API_URL ?? "http://127.0.0.1:3901";
 }
 export function sessionConfigPath(homeDir) {
     return join(homeDir, "Library", "Application Support", "Abitat", "config.json");

package/dist/index.js

@@ -1,12 +1,11 @@
 #!/usr/bin/env node
 import { spawn } from "node:child_process";
 import { realpathSync } from "node:fs";
-import { connect } from "node:net";
-import { homedir, hostname } from "node:os";
+import { homedir } 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";
+import { createIphoneStartupPlan } 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) {
@@ -19,7 +18,6 @@ export function parseCommand(args) {
 export async function runCli(args, input = {}) {
     const parsed = parseCommand(args);
     const env = input.env ?? process.env;
-    const isEndpointListening = input.isEndpointListening ?? isTcpEndpointListening;
     const output = input.output ?? console.log;
     const openUrl = input.openUrl ?? openUrlInBrowser;
     const homeDir = input.homeDir ?? homedir();
@@ -47,65 +45,25 @@ export async function runCli(args, input = {}) {
     }
     if (parsed.command === "doctor") {
         const session = await loadCliSession(configPath);
-        output(session ? `Logged in to ${session.apiUrl}` : "Not logged in. Run `abitat login`.");
+        output("Local iPhone control does not require an Abitat hosted login.");
+        if (session) {
+            output(`Hosted web session: ${session.apiUrl}`);
+        }
         return 0;
     }
-    const session = (await loadCliSession(configPath)) ??
-        (await runLoginCommand({
-            apiUrl,
-            configPath,
-            fetchFn: input.fetchFn,
-            openUrl,
-            pollIntervalMs: input.pollIntervalMs
-        }));
-    const result = await prepareIphoneCommand({
+    const startupPlan = createIphoneStartupPlan({
         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
+        endpoint: readOption(args, "--endpoint") ?? env.ABITAT_LOCAL_CONTROL_ENDPOINT,
+        port: numberOption(args, "--port", Number(env.ABITAT_LOCAL_CONTROL_PORT ?? 3901)),
+        transport: transportOption(readOption(args, "--transport") ?? "quick-tunnel")
     });
-    for (const process of result.startupPlan) {
-        const existingServerUrl = codexAppServerListenUrl(process);
-        if (existingServerUrl && (await isEndpointListening(existingServerUrl))) {
-            output(`Using existing Codex app server at ${existingServerUrl}`);
-            continue;
-        }
+    output("Starting local-first iPhone control on this Mac.");
+    output("The Mac will print a QR/manual pairing payload. No hosted domain or database is used.");
+    for (const process of 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 codexAppServerListenUrl(process) {
-    if (process.name !== "codex-app-server") {
-        return null;
-    }
-    const listenIndex = process.args.indexOf("--listen");
-    return listenIndex >= 0 ? (process.args[listenIndex + 1] ?? null) : null;
-}
-function isTcpEndpointListening(url, timeoutMs = 250) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const endpoint = new URL(url);
-        const socket = connect({
-            host: endpoint.hostname,
-            port: Number(endpoint.port || (endpoint.protocol === "wss:" ? 443 : 80))
-        });
-        const finish = (listening) => {
-            if (settled) {
-                return;
-            }
-            settled = true;
-            socket.destroy();
-            resolve(listening);
-        };
-        socket.setTimeout(timeoutMs, () => finish(false));
-        socket.on("connect", () => finish(true));
-        socket.on("error", () => finish(false));
-    });
-}
 function startProcess(process) {
     const resolved = resolveStartupProcess(process);
     spawn(resolved.command, resolved.args, {
@@ -114,7 +72,7 @@ function startProcess(process) {
     });
 }
 export function resolveStartupProcess(process, options = {}) {
-    if (process.name !== "host-daemon") {
+    if (process.command !== "abitat-host") {
         return process;
     }
     try {
@@ -138,6 +96,28 @@ function openUrlInBrowser(url) {
     });
     child.unref();
 }
+function readOption(args, option) {
+    const index = args.indexOf(option);
+    return index >= 0 ? args[index + 1] : undefined;
+}
+function numberOption(args, option, fallback) {
+    const value = readOption(args, option);
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed >= 0 ? parsed : fallback;
+}
+function transportOption(value) {
+    if (value === "auto" ||
+        value === "local" ||
+        value === "tailscale" ||
+        value === "quick-tunnel" ||
+        value === "manual") {
+        return value;
+    }
+    return "auto";
+}
 export function isCliEntrypoint(importMetaUrl, argvPath = process.argv[1]) {
     if (!argvPath) {
         return false;

package/dist/iphone.js

@@ -1,102 +1,18 @@
-import { setTimeout as delay } from "node:timers/promises";
-const DEFAULT_HOST_REGISTER_ATTEMPTS = 8;
-const DEFAULT_HOST_REGISTER_RETRY_DELAY_MS = 1000;
 export function createIphoneStartupPlan(input) {
     return [
         {
-            name: "codex-app-server",
-            command: "codex",
-            args: ["app-server", "--listen", input.codexServerUrl, "--analytics-default-enabled"]
-        },
-        {
-            name: "host-daemon",
+            name: "local-control-server",
             command: "abitat-host",
-            args: ["start"],
-            env: {
-                ABITAT_API_URL: input.apiUrl,
-                ABITAT_HOST_TOKEN: input.hostToken,
-                ABITAT_MACHINE_ID: input.machineId,
-                CODEX_APP_SERVER_URL: input.codexServerUrl
-            }
+            args: [
+                "iphone",
+                "--port",
+                String(input.port),
+                "--transport",
+                input.transport,
+                "--codex-server-url",
+                input.codexServerUrl,
+                ...(input.endpoint ? ["--endpoint", input.endpoint] : [])
+            ]
         }
     ];
 }
-export async function registerHost(input) {
-    const fetchFn = input.fetchFn ?? fetch;
-    let lastError;
-    const maxAttempts = Math.max(1, input.maxAttempts ?? DEFAULT_HOST_REGISTER_ATTEMPTS);
-    const retryDelayMs = input.retryDelayMs ?? DEFAULT_HOST_REGISTER_RETRY_DELAY_MS;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        try {
-            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) {
-                return parseHostRegistration(await response.json());
-            }
-            const error = new Error(`Unable to register host (${response.status})`);
-            if (!isTransientHostedStatus(response.status) || attempt >= maxAttempts) {
-                throw error;
-            }
-            lastError = error;
-        }
-        catch (error) {
-            if (!isTransientFetchError(error) || attempt >= maxAttempts) {
-                throw error;
-            }
-            lastError = error;
-        }
-        if (retryDelayMs > 0) {
-            await delay(retryDelayMs);
-        }
-    }
-    throw lastError instanceof Error ? lastError : new Error("Unable to register host");
-}
-function parseHostRegistration(value) {
-    const body = value;
-    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, "");
-}
-function isTransientHostedStatus(status) {
-    return status === 429 || status === 500 || status === 502 || status === 503 || status === 504;
-}
-function isTransientFetchError(error) {
-    return error instanceof TypeError;
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@abitat_reece/cli",
   "private": false,
-  "version": "0.1.5",
+  "version": "0.1.6",
   "description": "Remote Codex control from Mac and iPhone",
   "type": "module",
   "bin": {
@@ -15,7 +15,7 @@
     "node": ">=22"
   },
   "dependencies": {
-    "@abitat_reece/host-daemon": "0.1.5"
+    "@abitat_reece/host-daemon": "0.1.6"
   },
   "devDependencies": {
     "@types/node": "25.6.0",