@miosa/cli 1.0.37 → 1.0.39

package/dist/commands/sandbox.js

@@ -372,12 +372,16 @@ export function register(program) {
     // exec — positional command arg; --data body overrides when supplied
     addDataOption(sandbox
         .command("exec <sandbox-id> [command...]")
-        .description("Run a command inside a Sandbox (positional args joined as shell command)")
+        .description('Run a command inside a Sandbox (positional args joined as shell command). Use `--` before the command to pass flags, e.g. `sandbox exec <id> -- bash -c "cd x && y"`.')
+        .allowUnknownOption()
+        .allowExcessArguments()
         .option("--cwd <path>", "Working directory inside the Sandbox")
         .option("--workdir <path>", "Alias for --cwd")
         .option("--env <pair>", "Environment variable KEY=VALUE. Repeatable.", collectOption, [])
         .option("--background", "Start the command in the background and return immediately")
         .option("--detached", "Create a durable backend command and return command_id immediately")
+        .option("--follow", "Stream command output until it exits (alias --stream)")
+        .option("--stream", "Alias for --follow")
         .option("--user <user>", "Run command as user")
         .option("--sudo", "Run command through sudo")
         .option("--tty", "Request TTY metadata for command resource")
@@ -385,11 +389,12 @@ export function register(program) {
         .option("--timeout <sec>", "Exec timeout in seconds", parseIntegerOption))
         .option("--json", "Output as JSON")
         .action((id, words, opts) => runAction(async () => {
+        opts.follow = opts.follow || opts.stream;
         if (opts.data) {
             await postAndPrint(`/sandboxes/${enc(id)}/exec`, opts, {});
             return;
         }
-        const cmd = words.join(" ");
+        const cmd = joinCommandWords(words);
         const effectiveCommand = opts.background
             ? backgroundCommand(cmd)
             : cmd;
@@ -403,7 +408,7 @@ export function register(program) {
         }
         const env = parseEnvPairs(opts.env ?? []);
         if (opts.detached) {
-            const result = await createSandboxCommand(id, cmd, {
+            const result = await createSandboxCommand(id, words.join(" "), {
                 cwd,
                 env,
                 user: opts.user,
@@ -419,6 +424,10 @@ export function register(program) {
             console.log(String(result["id"] ?? result["command_id"] ?? ""));
             return;
         }
+        if (opts.follow) {
+            await runFollowExec(id, cmd, cwd, env, opts.timeout, opts);
+            return;
+        }
         if (Object.keys(env).length > 0)
             body["env"] = env;
         if (opts.timeout != null)
@@ -428,12 +437,16 @@ export function register(program) {
     // run — alias for exec with identical semantics
     addDataOption(sandbox
         .command("run <sandbox-id> [command...]")
-        .description("Run a command inside a Sandbox (alias for exec)")
+        .description("Run a command inside a Sandbox (alias for exec). Use `--` before the command to pass flags.")
+        .allowUnknownOption()
+        .allowExcessArguments()
         .option("--cwd <path>", "Working directory inside the Sandbox")
         .option("--workdir <path>", "Alias for --cwd")
         .option("--env <pair>", "Environment variable KEY=VALUE. Repeatable.", collectOption, [])
         .option("--background", "Start the command in the background and return immediately")
         .option("--detached", "Create a durable backend command and return command_id immediately")
+        .option("--follow", "Stream command output until it exits (alias --stream)")
+        .option("--stream", "Alias for --follow")
         .option("--user <user>", "Run command as user")
         .option("--sudo", "Run command through sudo")
         .option("--tty", "Request TTY metadata for command resource")
@@ -441,11 +454,12 @@ export function register(program) {
         .option("--timeout <sec>", "Exec timeout in seconds", parseIntegerOption))
         .option("--json", "Output as JSON")
         .action((id, words, opts) => runAction(async () => {
+        opts.follow = opts.follow || opts.stream;
         if (opts.data) {
             await postAndPrint(`/sandboxes/${enc(id)}/exec`, opts, {});
             return;
         }
-        const cmd = words.join(" ");
+        const cmd = joinCommandWords(words);
         const effectiveCommand = opts.background
             ? backgroundCommand(cmd)
             : cmd;
@@ -459,7 +473,7 @@ export function register(program) {
         }
         const env = parseEnvPairs(opts.env ?? []);
         if (opts.detached) {
-            const result = await createSandboxCommand(id, cmd, {
+            const result = await createSandboxCommand(id, words.join(" "), {
                 cwd,
                 env,
                 user: opts.user,
@@ -475,12 +489,46 @@ export function register(program) {
             console.log(String(result["id"] ?? result["command_id"] ?? ""));
             return;
         }
+        if (opts.follow) {
+            await runFollowExec(id, cmd, cwd, env, opts.timeout, opts);
+            return;
+        }
         if (Object.keys(env).length > 0)
             body["env"] = env;
         if (opts.timeout != null)
             body["timeout"] = opts.timeout;
         await postAndPrint(`/sandboxes/${enc(id)}/exec`, opts, body);
     }));
+    sandbox
+        .command("ports <sandbox-id>")
+        .description("List listening TCP ports inside a Sandbox")
+        .option("--json", "Output as JSON")
+        .action((id, opts) => runAction(async () => {
+        const c = client();
+        const result = await execSandboxRaw(c, id, "ss -ltnH 2>/dev/null || cat /proc/net/tcp /proc/net/tcp6 2>/dev/null");
+        const stdout = String(result["stdout"] ?? "");
+        const ports = parseListeningPorts(stdout);
+        if (isJsonMode(opts)) {
+            console.log(JSON.stringify(ports, null, 2));
+            return;
+        }
+        if (ports.length === 0) {
+            console.log(chalk.dim("(no listening ports)"));
+            return;
+        }
+        renderTable(ports, [
+            {
+                header: "PORT",
+                key: "port",
+                width: 8,
+            },
+            {
+                header: "ADDRESS",
+                key: "address",
+                width: 24,
+            },
+        ]);
+    }));
     sandbox
         .command("deploy [local-dir]")
         .description("Upload an app directory, start it in a sandbox, expose a preview URL, and wait for readiness")
@@ -595,7 +643,8 @@ export function register(program) {
         .option("--database <mode>", "none, create:postgres, postgres, or existing:<db-id>")
         .option("--port <port>", "Runtime port for dynamic deployments", parseIntegerOption)
         .option("--wait", "Wait for the production URL to answer")
-        .option("--timeout <duration>", "Wait timeout", parseDurationSec, 180)
+        .option("--no-wait", "Return immediately without waiting (this is the default)")
+        .option("--timeout <duration>", "Wait timeout", parseDurationSec, 600)
         .option("--json", "Output as JSON")
         .action((id, opts) => runAction(async () => {
         const result = await publishSandbox(id, opts);
@@ -740,15 +789,29 @@ export function register(program) {
             console.log(JSON.stringify(result, null, 2));
             return;
         }
-        const rows = Array.isArray(result) ? result : [];
+        const rows = Array.isArray(result)
+            ? result
+            : [];
         if (rows.length === 0) {
             console.log(chalk.dim("No sandbox env vars."));
             return;
         }
         renderTable(rows, [
-            { header: "NAME", key: "name", width: 32 },
-            { header: "VALUE", key: "preview", width: 24 },
-            { header: "UPDATED", key: "updated_at", width: 28 },
+            {
+                header: "NAME",
+                key: "name",
+                width: 32,
+            },
+            {
+                header: "VALUE",
+                key: "preview",
+                width: 24,
+            },
+            {
+                header: "UPDATED",
+                key: "updated_at",
+                width: 28,
+            },
         ]);
     }));
     env
@@ -1554,13 +1617,20 @@ function validateServiceName(name) {
 async function deploySandbox(localDir, opts) {
     const sourceDir = path.resolve(localDir);
     const sourceBacked = !!opts.source;
-    if (!sourceBacked && (!fs.existsSync(sourceDir) || !fs.statSync(sourceDir).isDirectory())) {
+    if (!sourceBacked &&
+        (!fs.existsSync(sourceDir) || !fs.statSync(sourceDir).isDirectory())) {
         throw new UserError(`Local directory not found: ${sourceDir}`);
     }
     const c = client();
-    let appManifest = sourceBacked ? null : loadAppManifest(sourceDir)?.manifest ?? null;
+    let appManifest = sourceBacked
+        ? null
+        : (loadAppManifest(sourceDir)?.manifest ?? null);
     const detection = sourceBacked ? null : detectFramework(sourceDir);
-    const port = opts.port ?? opts.publishPort ?? manifestPort(appManifest) ?? detection?.port ?? 5173;
+    const port = opts.port ??
+        opts.publishPort ??
+        manifestPort(appManifest) ??
+        detection?.port ??
+        5173;
     const probePath = opts.probePath ?? manifestProbePath(appManifest) ?? "/";
     let remoteWorkdir = normalizeRemoteWorkdir(appManifest?.workdir ?? "/workspace");
     const start = opts.start ??
@@ -1595,9 +1665,7 @@ async function deploySandbox(localDir, opts) {
     }
     const resolvedPort = opts.port ?? opts.publishPort ?? manifestPort(appManifest) ?? port;
     const resolvedProbePath = opts.probePath ?? manifestProbePath(appManifest) ?? probePath;
-    const resolvedStart = opts.start ??
-        manifestStartCommand(appManifest) ??
-        start;
+    const resolvedStart = opts.start ?? manifestStartCommand(appManifest) ?? start;
     const installCommand = opts.install === false
         ? null
         : (opts.installCommand ??
@@ -1632,6 +1700,41 @@ async function deploySandbox(localDir, opts) {
         latency_ms: edge.latency_ms ?? null,
     };
 }
+const NON_TERMINAL_DEPLOY_STATES = new Set([
+    "building",
+    "pending",
+    "queued",
+    "deploying",
+]);
+// Bug 9: look for an existing non-terminal deployment with a matching name so
+// retries attach a new release instead of creating a duplicate app. Defensive:
+// returns null (fall back to create) if the list call fails or finds nothing.
+async function findExistingDeploymentByName(c, name) {
+    try {
+        const raw = unwrap(await c.apiGet(apiPath("/deployments")));
+        const items = Array.isArray(raw)
+            ? raw
+            : Array.isArray((asRecord(raw) ?? {})["data"])
+                ? (asRecord(raw) ?? {})["data"]
+                : [];
+        for (const item of items) {
+            const rec = asRecord(item);
+            if (!rec)
+                continue;
+            if (stringField(rec, "name") !== name)
+                continue;
+            const state = (stringField(rec, "state") ?? "").toLowerCase();
+            const id = stringField(rec, "id");
+            if (id && NON_TERMINAL_DEPLOY_STATES.has(state)) {
+                return { id, state };
+            }
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 async function publishSandbox(sandboxId, opts) {
     const c = client();
     const body = {
@@ -1642,6 +1745,16 @@ async function publishSandbox(sandboxId, opts) {
     };
     if (opts.app)
         body["deployment_id"] = opts.app;
+    // Bug 9: avoid creating a duplicate deployment on retry. When publishing by
+    // name (no explicit app id), reuse an existing non-terminal deployment with
+    // the same name by attaching a new release to it.
+    if (opts.name && !opts.app) {
+        const existing = await findExistingDeploymentByName(c, opts.name);
+        if (existing) {
+            body["deployment_id"] = existing.id;
+            deployStep(opts, chalk.dim(`Attaching to existing deployment ${existing.id} (${existing.state})`));
+        }
+    }
     if (opts.name)
         body["name"] = opts.name;
     if (opts.slug)
@@ -1724,7 +1837,8 @@ async function waitForDeploymentReady(c, deploymentId, timeoutSec) {
         }
         await sleep(2000);
     }
-    throw new UserError(`Deployment ${deploymentId} did not become ready within ${timeoutSec}s.`, last ? `Last state: ${String(last["state"] ?? "unknown")}` : undefined);
+    const lastState = last ? String(last["state"] ?? "unknown") : "unknown";
+    throw new UserError(`Deployment still building after ${timeoutSec}s — it may still finish. Re-check with \`miosa sandbox show ${deploymentId}\` or \`miosa deploy logs\`.`, `Last state: ${lastState}`);
 }
 function parsePublishDatabase(value) {
     if (!value)
@@ -1820,7 +1934,11 @@ async function createSandboxForDeploy(c, template, name, source) {
 async function readRemoteAppManifest(c, sandboxId, timeoutSec) {
     const deadline = Date.now() + Math.min(timeoutSec, 120) * 1000;
     while (Date.now() < deadline) {
-        for (const filename of ["miosa.app.yml", "miosa.app.yaml", "miosa.app.json"]) {
+        for (const filename of [
+            "miosa.app.yml",
+            "miosa.app.yaml",
+            "miosa.app.json",
+        ]) {
             const result = await c
                 .apiPost(apiPath(`/sandboxes/${enc(sandboxId)}/exec`), {
                 command: `test -f /workspace/${filename} && cat /workspace/${filename}`,
@@ -1830,7 +1948,8 @@ async function readRemoteAppManifest(c, sandboxId, timeoutSec) {
                 .then(unwrap)
                 .catch(() => null);
             const row = asRecord(result);
-            if (Number(row?.["exit_code"] ?? 1) === 0 && typeof row?.["stdout"] === "string") {
+            if (Number(row?.["exit_code"] ?? 1) === 0 &&
+                typeof row?.["stdout"] === "string") {
                 return parseAppManifest(filename, row["stdout"]);
             }
         }
@@ -1926,6 +2045,98 @@ async function execSandbox(c, sandboxId, command, cwd, timeout) {
     }
     return result;
 }
+// Like execSandbox but does NOT throw on a non-zero exit code.
+async function execSandboxRaw(c, sandboxId, command, cwd, timeout) {
+    const body = { command: commandInCwd(command, cwd) };
+    if (cwd) {
+        body["cwd"] = cwd;
+        body["dir"] = cwd;
+    }
+    if (timeout != null)
+        body["timeout"] = timeout;
+    return unwrap(await c.apiPost(apiPath(`/sandboxes/${enc(sandboxId)}/exec`), body));
+}
+function parseListeningPorts(stdout) {
+    const lines = stdout.split("\n").map((l) => l.trim());
+    const seen = new Set();
+    const out = [];
+    // ss -ltnH columns: State Recv-Q Send-Q Local-Address:Port Peer-Address:Port
+    const ssLine = /^LISTEN\s+\d+\s+\d+\s+(\S+):(\d+)\s+/;
+    // /proc/net/tcp: sl local_address rem_address st ... (hex)
+    const procLine = /^\d+:\s+([0-9A-Fa-f]+):([0-9A-Fa-f]+)\s+\S+\s+([0-9A-Fa-f]+)/;
+    for (const line of lines) {
+        if (!line)
+            continue;
+        const ss = ssLine.exec(line);
+        if (ss && ss[2]) {
+            const port = Number(ss[2]);
+            if (!seen.has(port)) {
+                seen.add(port);
+                out.push({ port, address: ss[1] ?? "*" });
+            }
+            continue;
+        }
+        const proc = procLine.exec(line);
+        if (proc && proc[3] === "0A" && proc[2]) {
+            const port = parseInt(proc[2], 16);
+            if (!Number.isNaN(port) && !seen.has(port)) {
+                seen.add(port);
+                out.push({ port, address: "*" });
+            }
+        }
+    }
+    out.sort((a, b) => a.port - b.port);
+    return out;
+}
+// Stream exec output: run in background to a log file, poll-read new bytes
+// until the process exits, then print the final exit code.
+async function runFollowExec(sandboxId, cmd, cwd, env, timeoutSec, opts) {
+    if (!cmd) {
+        throw new UserError("No command given to follow.");
+    }
+    const c = client();
+    const logPath = `/tmp/miosa-follow-${Date.now()}.log`;
+    const envPrefix = Object.entries(env)
+        .map(([k, v]) => `${k}=${shellQuote(v)} `)
+        .join("");
+    // Run command, capture exit code into a sentinel file, in the background.
+    const exitPath = `${logPath}.exit`;
+    const inner = `${envPrefix}${cmd}`;
+    const launch = `nohup sh -lc ${shellQuote(`( ${inner} ) > ${shellQuote(logPath)} 2>&1; echo $? > ${shellQuote(exitPath)}`)} >/dev/null 2>&1 & echo $!`;
+    const started = await execSandboxRaw(c, sandboxId, launch, cwd, timeoutSec);
+    const pid = String(started["stdout"] ?? "").trim();
+    if (!pid) {
+        throw new UserError("Could not start background command for --follow.");
+    }
+    const deadline = timeoutSec ? Date.now() + timeoutSec * 1000 : Infinity;
+    let offset = 0;
+    for (;;) {
+        const read = await execSandboxRaw(c, sandboxId, `tail -c +${offset + 1} ${shellQuote(logPath)} 2>/dev/null`);
+        const chunk = String(read["stdout"] ?? "");
+        if (chunk.length > 0) {
+            process.stdout.write(chunk);
+            offset += Buffer.byteLength(chunk);
+        }
+        const alive = await execSandboxRaw(c, sandboxId, `kill -0 ${shellQuote(pid)} 2>/dev/null && echo alive || echo done`);
+        if (String(alive["stdout"] ?? "").trim() === "done")
+            break;
+        if (Date.now() > deadline) {
+            console.error(chalk.yellow(`\nTimed out after ${timeoutSec}s — command may still be running (pid ${pid}).`));
+            return;
+        }
+        await sleep(1000);
+    }
+    // Drain any trailing output.
+    const tail = await execSandboxRaw(c, sandboxId, `tail -c +${offset + 1} ${shellQuote(logPath)} 2>/dev/null`);
+    const tailChunk = String(tail["stdout"] ?? "");
+    if (tailChunk.length > 0)
+        process.stdout.write(tailChunk);
+    const exitRead = await execSandboxRaw(c, sandboxId, `cat ${shellQuote(exitPath)} 2>/dev/null`);
+    const exitCode = Number(String(exitRead["stdout"] ?? "0").trim() || "0");
+    if (!isJsonMode(opts) && exitCode !== 0) {
+        console.error(chalk.red(`\nexit code: ${exitCode}`));
+    }
+}
 async function waitForInternalHttp(c, sandboxId, port, probePath, timeoutSec) {
     const deadline = Date.now() + timeoutSec * 1000;
     let last = { ok: false, status: null };
@@ -2237,6 +2448,15 @@ function buildNetworkPolicy(opts) {
 function shellQuote(value) {
     return `'${value.replace(/'/g, "'\\''")}'`;
 }
+// Join argv words back into a shell command, quoting only words that contain
+// whitespace or shell-significant characters. Simple tokens stay bare so
+// `exec <id> ls -la` reads naturally, while `bash -c "cd x && y"` survives.
+function joinCommandWords(words) {
+    const SAFE = /^[A-Za-z0-9_./:=@%+-]+$/;
+    return words
+        .map((word) => word.length > 0 && SAFE.test(word) ? word : shellQuote(word))
+        .join(" ");
+}
 function joinUrlPath(basePath, probePath) {
     const probe = probePath.startsWith("/") ? probePath : `/${probePath}`;
     if (!basePath || basePath === "/")