@longshot/cli 0.0.1 → 0.0.2

package/dist/cli.js

@@ -3,6 +3,7 @@ import { parseArgs } from "node:util";
 import { resolve, join, dirname } from "node:path";
 import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
 const __dirname = dirname(fileURLToPath(import.meta.url));
 function getVersion() {
     // Walk up from src/ or dist/ to find package.json
@@ -23,15 +24,19 @@ function printHelp() {
 Usage: longshot [options]
 
 Options:
-  -p, --port <number>   Port for the web server (default: 3333)
-  -d, --dir <path>      Project root directory (default: current directory)
-  -h, --help            Show this help message
-  -v, --version         Show version number
+  -p, --port <number>      Port for the web server (default: 3333)
+  -d, --dir <path>         Project root directory (default: current directory)
+  -c, --connect            Connect to remote proxy tunnel
+      --proxy-url <url>    Proxy WebSocket URL (overrides auth.json / env)
+      --token <token>      Auth token (overrides auth.json / env)
+  -h, --help               Show this help message
+  -v, --version            Show version number
 
 Examples:
   longshot                    Start in current directory on port 3333
   longshot -p 8080            Start on port 8080
   longshot -d ~/my-project    Start with a specific project directory
+  longshot --connect          Start server and connect to proxy tunnel
 
 First run:
   If the target directory isn't a longshot project yet, you'll be guided
@@ -45,6 +50,9 @@ export function parseCliArgs(args) {
             dir: { type: "string", short: "d" },
             help: { type: "boolean", short: "h", default: false },
             version: { type: "boolean", short: "v", default: false },
+            connect: { type: "boolean", short: "c", default: false },
+            "proxy-url": { type: "string" },
+            token: { type: "string" },
         },
         strict: true,
         allowPositionals: false,
@@ -54,23 +62,44 @@ export function parseCliArgs(args) {
         dir: values.dir ? resolve(values.dir) : process.cwd(),
         help: values.help ?? false,
         version: values.version ?? false,
+        connect: values.connect ?? false,
+        proxyUrl: values["proxy-url"],
+        token: values.token,
     };
 }
+function loadAuthConfig() {
+    const authPath = join(homedir(), ".longshot", "auth.json");
+    try {
+        if (existsSync(authPath)) {
+            return JSON.parse(readFileSync(authPath, "utf-8"));
+        }
+    }
+    catch {
+        // Ignore malformed auth.json
+    }
+    return {};
+}
+export function resolveTunnelConfig(parsed) {
+    const auth = loadAuthConfig();
+    const proxyUrl = parsed.proxyUrl
+        || process.env.LONGSHOT_PROXY_URL
+        || auth.proxyUrl;
+    const token = parsed.token
+        || process.env.LONGSHOT_TOKEN
+        || auth.token;
+    return { proxyUrl, token };
+}
 class InquirerPrompter {
     async selectMode() {
-        const inquirer = await import("inquirer");
+        const { select } = await import("@inquirer/prompts");
         try {
-            const { mode } = await inquirer.default.prompt([
-                {
-                    type: "list",
-                    name: "mode",
-                    message: "How would you like to use longshot?",
-                    choices: [
-                        { name: "Single project — initialize this directory", value: "single" },
-                        { name: "Multi-project — manage multiple subdirectories", value: "multi" },
-                    ],
-                },
-            ]);
+            const mode = await select({
+                message: "How would you like to use longshot?",
+                choices: [
+                    { name: "Single project — initialize this directory", value: "single" },
+                    { name: "Multi-project — manage multiple subdirectories", value: "multi" },
+                ],
+            });
             return mode;
         }
         catch {
@@ -78,16 +107,12 @@ class InquirerPrompter {
         }
     }
     async selectFolders(folders) {
-        const inquirer = await import("inquirer");
+        const { checkbox } = await import("@inquirer/prompts");
         try {
-            const { selected } = await inquirer.default.prompt([
-                {
-                    type: "checkbox",
-                    name: "selected",
-                    message: "Select project directories:",
-                    choices: folders.map((f) => ({ name: f, value: f })),
-                },
-            ]);
+            const selected = await checkbox({
+                message: "Select project directories:",
+                choices: folders.map((f) => ({ name: f, value: f })),
+            });
             return selected;
         }
         catch {
@@ -162,9 +187,41 @@ async function main() {
     // Set environment for the server
     process.env.PORT = String(parsed.port);
     process.env.PROJECT_ROOT = parsed.dir;
+    process.env.LONGSHOT_CLI = "1";
     // Start the server
     const { startServer } = await import("./index.js");
     await startServer();
+    // Start tunnel if --connect flag is used
+    if (parsed.connect) {
+        const { proxyUrl, token } = resolveTunnelConfig(parsed);
+        if (!proxyUrl || !token) {
+            console.error("Tunnel requires --proxy-url and --token (or ~/.longshot/auth.json or LONGSHOT_PROXY_URL/LONGSHOT_TOKEN env vars)");
+            process.exit(1);
+        }
+        const { TunnelClient } = await import("./tunnel.js");
+        const tunnel = new TunnelClient({
+            proxyUrl,
+            authToken: token,
+            localPort: parsed.port,
+            onConnected: () => console.log("Connected to proxy"),
+            onDisconnected: () => console.log("Disconnected from proxy, reconnecting..."),
+            onError: (err) => console.error("Tunnel error:", err.message),
+        });
+        const shutdown = () => {
+            console.log("Disconnecting tunnel...");
+            tunnel.disconnect();
+            process.exit(0);
+        };
+        process.on("SIGINT", shutdown);
+        process.on("SIGTERM", shutdown);
+        try {
+            await tunnel.connect();
+        }
+        catch (err) {
+            console.error("Failed to connect tunnel:", err.message);
+            process.exit(1);
+        }
+    }
 }
 main().catch((err) => {
     console.error("Fatal error:", err);

package/dist/index.js

@@ -1244,7 +1244,7 @@ export async function startServer() {
         }
     });
 }
-// Only start server when not imported as a module for testing
-if (!process.env.TESTING) {
+// Only start server when run directly (not imported by CLI or tests)
+if (!process.env.TESTING && !process.env.LONGSHOT_CLI) {
     startServer();
 }

package/dist/projects.js

@@ -64,17 +64,25 @@ export function detectMode() {
         renameSync(remcDir, newDir);
         console.log("Migrated .rem-c/ → .longshot/");
     }
+    const hasProjectsJson = existsSync(join(ROOT_DIR, ".longshot", "projects.json"));
     const hasLocalData = existsSync(join(ROOT_DIR, ".longshot"));
-    if (hasLocalData) {
-        // Project mode — single project, current behavior
+    if (hasProjectsJson) {
+        // Multi-project mode — parent dir has projects.json
+        multiProject = true;
+        autoDiscover();
+    }
+    else if (hasLocalData) {
+        // Single project mode — has .longshot/ but no projects.json
         multiProject = false;
         currentProjectRoot = ROOT_DIR;
         currentProjectName = null;
         return;
     }
-    // Parent mode — look for child projects
-    multiProject = true;
-    autoDiscover();
+    else {
+        // No data at all — look for child projects
+        multiProject = true;
+        autoDiscover();
+    }
     // Switch to the first project if any exist
     const projects = readProjects();
     if (projects.length > 0) {

package/dist/queue.js

@@ -415,7 +415,6 @@ Context available if needed:
                 break;
             }
             case "start-work": {
-                await store.updateTaskStatus(item.params.taskId, "in_progress");
                 const task = await store.getTask(item.params.taskId);
                 if (!task) {
                     await store.updateQueueItem(item.id, {
@@ -425,6 +424,15 @@ Context available if needed:
                     });
                     return;
                 }
+                // Skip duplicate start-work for tasks already complete/rejected
+                if (task.meta.status === "complete" || task.meta.status === "rejected" || task.meta.completed || task.meta.checkpoint) {
+                    await store.updateQueueItem(item.id, {
+                        status: "done",
+                        completedAt: new Date().toISOString(),
+                    });
+                    return;
+                }
+                await store.updateTaskStatus(item.params.taskId, "in_progress");
                 const prompt = `Implement task #${item.params.taskId}: ${task.meta.title}\n\nTask spec:\n${task.spec}`;
                 result = await runAgent(prompt, `Task #${item.params.taskId}: ${task.meta.title}`, task, item.params.taskId);
                 break;
@@ -440,6 +448,14 @@ Context available if needed:
                     });
                     return;
                 }
+                // Skip duplicate spec-update for tasks already complete
+                if (task.meta.status === "complete" || task.meta.status === "rejected") {
+                    await store.updateQueueItem(item.id, {
+                        status: "done",
+                        completedAt: new Date().toISOString(),
+                    });
+                    return;
+                }
                 const padId = String(task.meta.id).padStart(3, "0");
                 const taskDir = `.longshot/tasks/${padId}-${task.meta.slug}`;
                 const specPrompt = `Task #${taskIdForUpdate} "${task.meta.title}" has just been implemented and approved.
@@ -598,9 +614,18 @@ async function revertTaskStatusOnFailure(item) {
     if (!taskId)
         return;
     // Don't revert terminal statuses — a completed/rejected task should stay that way
+    // Also check for completed/checkpoint fields, since a duplicate start-work may have
+    // overwritten the status to in_progress even though the task was already done
     const task = await store.getTask(taskId);
-    if (task && (task.meta.status === "complete" || task.meta.status === "rejected"))
+    if (!task)
+        return;
+    if (task.meta.status === "complete" || task.meta.status === "rejected")
+        return;
+    if (task.meta.completed || task.meta.checkpoint) {
+        // Task was completed but status got overwritten — restore it
+        await store.updateTaskStatus(taskId, "complete");
         return;
+    }
     switch (item.type) {
         case "start-work": {
             // If there's a pending diff from a previous run, stay in_progress
@@ -666,18 +691,23 @@ export async function enqueue(type, params) {
         params.taskSlug = task.slug;
     }
     const item = await store.addQueueItem({ type, params });
-    // Set transitional task status immediately on enqueue
-    if (type === "start-work" && params.taskId) {
-        await store.updateTaskStatus(params.taskId, "queued");
-    }
-    else if (type === "refine-task" && params.taskId) {
-        await store.updateTaskStatus(params.taskId, "refining");
-    }
-    else if (type === "spec-update" && params.taskId) {
-        await store.updateTaskStatus(params.taskId, "approved");
-    }
-    else if (type === "fix-task" && params.taskId) {
-        await store.updateTaskStatus(params.taskId, "fixing");
+    // Set transitional task status immediately on enqueue — but only if the task
+    // is in the expected state. Never overwrite a "further along" or terminal status.
+    if (params.taskId) {
+        const task = await store.getTask(params.taskId);
+        const status = task?.meta.status;
+        if (type === "start-work" && status === "ready") {
+            await store.updateTaskStatus(params.taskId, "queued");
+        }
+        else if (type === "refine-task" && status === "drafting") {
+            await store.updateTaskStatus(params.taskId, "refining");
+        }
+        else if (type === "spec-update" && status === "in_progress") {
+            await store.updateTaskStatus(params.taskId, "approved");
+        }
+        else if (type === "fix-task" && status === "in_progress") {
+            await store.updateTaskStatus(params.taskId, "fixing");
+        }
     }
     // Start processing if not already running
     processNext().catch((err) => console.error("Queue processor error:", err));

package/dist/tunnel.js

@@ -0,0 +1,152 @@
+import WebSocket from "ws";
+const HOP_BY_HOP_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailers",
+    "transfer-encoding",
+    "upgrade",
+]);
+export class TunnelClient {
+    ws = null;
+    opts;
+    reconnectDelay = 1000;
+    reconnectTimer = null;
+    intentionalClose = false;
+    _connected = false;
+    constructor(opts) {
+        this.opts = opts;
+    }
+    connect() {
+        this.intentionalClose = false;
+        return new Promise((resolve, reject) => {
+            this.openConnection(resolve, reject);
+        });
+    }
+    disconnect() {
+        this.intentionalClose = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+        this._connected = false;
+    }
+    isConnected() {
+        return this._connected;
+    }
+    openConnection(onFirstConnect, onFirstError) {
+        const ws = new WebSocket(this.opts.proxyUrl);
+        this.ws = ws;
+        let registered = false;
+        ws.on("open", () => {
+            ws.send(JSON.stringify({ type: "register", token: this.opts.authToken }));
+        });
+        ws.on("message", (data) => {
+            let msg;
+            try {
+                msg = JSON.parse(data.toString());
+            }
+            catch {
+                return;
+            }
+            if (msg.type === "registered") {
+                registered = true;
+                this._connected = true;
+                this.reconnectDelay = 1000;
+                this.opts.onConnected?.();
+                onFirstConnect?.();
+                onFirstConnect = undefined;
+                onFirstError = undefined;
+            }
+            else if (msg.type === "error") {
+                const err = new Error(msg.message);
+                this.opts.onError?.(err);
+                if (!registered && onFirstError) {
+                    onFirstError(err);
+                    onFirstConnect = undefined;
+                    onFirstError = undefined;
+                }
+            }
+            else if (msg.type === "ping") {
+                ws.send(JSON.stringify({ type: "pong" }));
+            }
+            else if (msg.type === "request") {
+                this.handleRequest(msg);
+            }
+        });
+        ws.on("close", () => {
+            this._connected = false;
+            this.opts.onDisconnected?.();
+            if (!this.intentionalClose) {
+                this.scheduleReconnect();
+            }
+        });
+        ws.on("error", (err) => {
+            this.opts.onError?.(err);
+            if (!registered && onFirstError) {
+                onFirstError(err);
+                onFirstConnect = undefined;
+                onFirstError = undefined;
+            }
+        });
+    }
+    scheduleReconnect() {
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = null;
+            this.openConnection();
+        }, this.reconnectDelay);
+        this.reconnectDelay = Math.min(this.reconnectDelay * 2, 30000);
+    }
+    async handleRequest(req) {
+        const url = `http://localhost:${this.opts.localPort}${req.path}`;
+        const headers = {};
+        if (req.headers) {
+            for (const [k, v] of Object.entries(req.headers)) {
+                if (!HOP_BY_HOP_HEADERS.has(k.toLowerCase())) {
+                    headers[k] = v;
+                }
+            }
+        }
+        try {
+            const resp = await fetch(url, {
+                method: req.method,
+                headers,
+                body: req.method !== "GET" && req.method !== "HEAD" ? req.body : undefined,
+            });
+            const respHeaders = {};
+            resp.headers.forEach((v, k) => {
+                if (!HOP_BY_HOP_HEADERS.has(k.toLowerCase())) {
+                    respHeaders[k] = v;
+                }
+            });
+            const body = await resp.text();
+            this.send({
+                type: "response",
+                id: req.id,
+                status: resp.status,
+                headers: respHeaders,
+                body,
+            });
+        }
+        catch {
+            this.send({
+                type: "response",
+                id: req.id,
+                status: 502,
+                headers: {},
+                body: "Local server unavailable",
+            });
+        }
+    }
+    send(msg) {
+        if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(msg));
+        }
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@longshot/cli",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Mobile-first Claude orchestrator with spec-driven workflow",
   "type": "module",
   "bin": {
@@ -24,12 +24,13 @@
     "@hono/node-server": "^1.19.9",
     "diff2html": "^3.4.56",
     "hono": "^4.11.9",
-    "inquirer": "^13.2.4",
-    "marked": "^17.0.2"
+    "@inquirer/prompts": "^7.0.0",
+    "marked": "^17.0.2",
+    "ws": "^8.19.0"
   },
   "devDependencies": {
-    "@types/inquirer": "^9.0.9",
     "@types/node": "^25.2.3",
+    "@types/ws": "^8.18.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }