@miosa/cli 1.0.54 → 1.0.56

package/dist/commands/sandbox.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../src/commands/sandbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAgDzC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA0iE/C"}
+{"version":3,"file":"sandbox.d.ts","sourceRoot":"","sources":["../../src/commands/sandbox.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAsDzC,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CA8iE/C"}

package/dist/commands/sandbox.js

@@ -15,7 +15,7 @@ import { handleError, isJsonMode } from "./util.js";
 import { renderTable } from "../ui/table.js";
 import { formatDuration, hintBlock, icon, kvPanel, printBanner, printElapsed, } from "../ui/render.js";
 import { formatBytes } from "../ui/progress.js";
-import { UserError } from "../errors.js";
+import { ApiResponseError, MiosaError, NetworkError, ServerError, UserError, } from "../errors.js";
 export function register(program) {
     // -------------------------------------------------------------------------
     // sandbox / sandboxes command group — built manually to avoid subcommand
@@ -553,21 +553,26 @@ export function register(program) {
         .option("--timeout <duration>", "Wait timeout, e.g. 180s or 3m", parseDurationSec, 180)
         .option("--probe-path <path>", "HTTP path to probe")
         .option("--json", "Output as JSON")
-        .action((localDir = ".", opts) => runAction(async () => {
-        const result = await deploySandbox(localDir, opts);
-        if (isJsonMode(opts)) {
-            console.log(JSON.stringify(result, null, 2));
-            return;
+        .action(async (localDir = ".", opts) => {
+        try {
+            const result = await deploySandbox(localDir, opts);
+            if (isJsonMode(opts)) {
+                console.log(JSON.stringify(result, null, 2));
+                return;
+            }
+            console.log();
+            console.log(`  ${chalk.bold("Sandbox")}  ${result.sandbox_id}`);
+            console.log(`  ${chalk.bold("Port")}     ${result.port}`);
+            console.log(`  ${chalk.bold("Preview")}  ${chalk.cyan(result.preview_url)}`);
+            console.log(`  ${chalk.bold("Ready")}    ${result.preview_ready
+                ? chalk.green("yes")
+                : chalk.yellow("not verified")}`);
+            console.log();
         }
-        console.log();
-        console.log(`  ${chalk.bold("Sandbox")}  ${result.sandbox_id}`);
-        console.log(`  ${chalk.bold("Port")}     ${result.port}`);
-        console.log(`  ${chalk.bold("Preview")}  ${chalk.cyan(result.preview_url)}`);
-        console.log(`  ${chalk.bold("Ready")}    ${result.preview_ready
-            ? chalk.green("yes")
-            : chalk.yellow("not verified")}`);
-        console.log();
-    }));
+        catch (err) {
+            handleSandboxDeployError(err, opts);
+        }
+    });
     sandbox
         .command("preview <sandbox-id>")
         .description("Expose a sandbox port and optionally wait for the public preview to answer")
@@ -908,8 +913,7 @@ export function register(program) {
             const contentBytes = fs.existsSync(contentArg)
                 ? fs.readFileSync(contentArg)
                 : Buffer.from(contentArg, "utf8");
-            const base64 = contentBytes.toString("base64");
-            const result = await fetchApiRaw(apiPath(`/sandboxes/${enc(id)}/files`), { path: remotePath, content: base64 });
+            const result = await writeBytesToSandbox(client(), id, remotePath, contentBytes);
             if (!isJsonMode(opts)) {
                 console.log(chalk.green(`Written to ${remotePath}`));
             }
@@ -970,10 +974,8 @@ export function register(program) {
                 console.error(chalk.red(`File not found: ${localPath}`));
                 process.exit(1);
             }
-            const data = fs.readFileSync(localPath);
-            const base64 = data.toString("base64");
             const c = client();
-            const result = await c.apiPost(apiPath(`/sandboxes/${enc(id)}/files`), { path: remotePath, content: base64 });
+            const result = await writeBytesToSandbox(c, id, remotePath, fs.readFileSync(localPath));
             if (isJsonMode(opts)) {
                 printValue(result, opts);
             }
@@ -1499,6 +1501,18 @@ async function runSandboxPortForward(id, opts) {
     process.stderr.write("\n");
     server.close();
 }
+class SandboxDeployPartialError extends Error {
+    causeError;
+    sandboxId;
+    recoveryCommand;
+    constructor(causeError, sandboxId, recoveryCommand) {
+        super(causeError instanceof Error ? causeError.message : String(causeError));
+        this.causeError = causeError;
+        this.sandboxId = sandboxId;
+        this.recoveryCommand = recoveryCommand;
+        this.name = "SandboxDeployPartialError";
+    }
+}
 async function showSandboxWithPreview(sandboxId, port, probePath) {
     const c = client();
     const sandbox = unwrap(await c.apiGet(apiPath(`/sandboxes/${enc(sandboxId)}`)));
@@ -1643,69 +1657,79 @@ async function deploySandbox(localDir, opts) {
     const start = opts.start ??
         manifestStartCommand(appManifest) ??
         defaultStartCommand(detection?.framework ?? appManifest?.framework, port);
-    const sandboxId = opts.sandbox ??
-        (deployStep(opts, "Creating sandbox"),
-            await createSandboxForDeploy(c, opts.template ?? appManifest?.template ?? "miosa-sandbox", opts.name, {
+    let sandboxId = opts.sandbox ?? null;
+    try {
+        if (!sandboxId) {
+            deployStep(opts, "Creating sandbox");
+            sandboxId = await createSandboxForDeploy(c, opts.template ?? appManifest?.template ?? "miosa-sandbox", opts.name, {
                 source: opts.source,
                 revision: opts.revision,
                 depth: opts.depth,
-            }));
-    deployStep(opts, "Waiting for sandbox");
-    await waitForSandboxRunning(c, sandboxId, Math.min(opts.timeout, 120));
-    if (sourceBacked) {
-        deployStep(opts, "Waiting for source import");
-        appManifest = await readRemoteAppManifest(c, sandboxId, opts.timeout);
-        remoteWorkdir = normalizeRemoteWorkdir(appManifest?.workdir ?? "/workspace");
-    }
-    else {
-        deployStep(opts, "Uploading files");
-        const archivePath = createDeployArchive(sourceDir);
-        const remoteArchive = `/tmp/miosa-deploy-${Date.now()}.tgz`;
-        try {
-            await uploadFileToSandbox(c, sandboxId, archivePath, remoteArchive);
-            deployStep(opts, "Extracting workspace");
-            await execSandbox(c, sandboxId, `mkdir -p ${shellQuote(remoteWorkdir)} && tar -xzf ${shellQuote(remoteArchive)} -C ${shellQuote(remoteWorkdir)}`, "/");
+            });
         }
-        finally {
-            fs.rmSync(archivePath, { force: true });
+        deployStep(opts, "Waiting for sandbox");
+        await waitForSandboxRunning(c, sandboxId, Math.min(opts.timeout, 120));
+        if (sourceBacked) {
+            deployStep(opts, "Waiting for source import");
+            appManifest = await readRemoteAppManifest(c, sandboxId, opts.timeout);
+            remoteWorkdir = normalizeRemoteWorkdir(appManifest?.workdir ?? "/workspace");
         }
+        else {
+            deployStep(opts, "Uploading files");
+            const archivePath = createDeployArchive(sourceDir);
+            const remoteArchive = `/tmp/miosa-deploy-${Date.now()}.tgz`;
+            try {
+                await uploadFileToSandbox(c, sandboxId, archivePath, remoteArchive);
+                deployStep(opts, "Extracting workspace");
+                await execSandbox(c, sandboxId, `mkdir -p ${shellQuote(remoteWorkdir)} && tar -xzf ${shellQuote(remoteArchive)} -C ${shellQuote(remoteWorkdir)}`, "/");
+            }
+            finally {
+                fs.rmSync(archivePath, { force: true });
+            }
+        }
+        const resolvedPort = opts.port ?? opts.publishPort ?? manifestPort(appManifest) ?? port;
+        const resolvedProbePath = opts.probePath ?? manifestProbePath(appManifest) ?? probePath;
+        const resolvedStart = opts.start ?? manifestStartCommand(appManifest) ?? start;
+        const installCommand = opts.install === false
+            ? null
+            : (opts.installCommand ??
+                (appManifest?.install === false ? null : appManifest?.install) ??
+                (sourceBacked ? "npm install" : defaultInstallCommand(sourceDir)));
+        if (installCommand) {
+            deployStep(opts, `Installing dependencies: ${installCommand}`);
+            await execSandbox(c, sandboxId, installCommand, remoteWorkdir, opts.timeout);
+        }
+        deployStep(opts, `Starting app on port ${resolvedPort}`);
+        await execSandbox(c, sandboxId, `fuser -k ${resolvedPort}/tcp >/dev/null 2>&1 || true; nohup sh -lc ${shellQuote(resolvedStart)} > ${shellQuote(`/tmp/miosa-app-${resolvedPort}.log`)} 2>&1 & echo $!`, remoteWorkdir);
+        deployStep(opts, "Checking internal app readiness");
+        const internal = await waitForInternalHttp(c, sandboxId, resolvedPort, resolvedProbePath, Math.min(opts.timeout, 60));
+        deployStep(opts, "Creating public preview route");
+        const exposed = await c.apiPost(apiPath(`/sandboxes/${enc(sandboxId)}/expose`), { port: resolvedPort, title: "app preview" });
+        const previewUrl = extractUrl(unwrap(exposed));
+        if (!previewUrl) {
+            throw new UserError("Sandbox expose did not return a preview URL.");
+        }
+        if (opts.wait)
+            deployStep(opts, "Checking public preview readiness");
+        const edge = opts.wait
+            ? await waitForPublicPreview(previewUrl, resolvedProbePath, opts.timeout)
+            : { ok: false, status: null };
+        return {
+            sandbox_id: sandboxId,
+            port: resolvedPort,
+            preview_url: previewUrl,
+            preview_ready: edge.ok,
+            internal_status: internal.status,
+            edge_status: edge.status,
+            latency_ms: edge.latency_ms ?? null,
+        };
     }
-    const resolvedPort = opts.port ?? opts.publishPort ?? manifestPort(appManifest) ?? port;
-    const resolvedProbePath = opts.probePath ?? manifestProbePath(appManifest) ?? probePath;
-    const resolvedStart = opts.start ?? manifestStartCommand(appManifest) ?? start;
-    const installCommand = opts.install === false
-        ? null
-        : (opts.installCommand ??
-            (appManifest?.install === false ? null : appManifest?.install) ??
-            (sourceBacked ? "npm install" : defaultInstallCommand(sourceDir)));
-    if (installCommand) {
-        deployStep(opts, `Installing dependencies: ${installCommand}`);
-        await execSandbox(c, sandboxId, installCommand, remoteWorkdir, opts.timeout);
-    }
-    deployStep(opts, `Starting app on port ${resolvedPort}`);
-    await execSandbox(c, sandboxId, `fuser -k ${resolvedPort}/tcp >/dev/null 2>&1 || true; nohup sh -lc ${shellQuote(resolvedStart)} > ${shellQuote(`/tmp/miosa-app-${resolvedPort}.log`)} 2>&1 & echo $!`, remoteWorkdir);
-    deployStep(opts, "Checking internal app readiness");
-    const internal = await waitForInternalHttp(c, sandboxId, resolvedPort, resolvedProbePath, Math.min(opts.timeout, 60));
-    deployStep(opts, "Creating public preview route");
-    const exposed = await c.apiPost(apiPath(`/sandboxes/${enc(sandboxId)}/expose`), { port: resolvedPort, title: "app preview" });
-    const previewUrl = extractUrl(unwrap(exposed));
-    if (!previewUrl) {
-        throw new UserError("Sandbox expose did not return a preview URL.");
+    catch (err) {
+        if (sandboxId) {
+            throw new SandboxDeployPartialError(err, sandboxId, recoveryCommandForSandboxDeploy(sandboxId, opts, localDir));
+        }
+        throw err;
     }
-    if (opts.wait)
-        deployStep(opts, "Checking public preview readiness");
-    const edge = opts.wait
-        ? await waitForPublicPreview(previewUrl, resolvedProbePath, opts.timeout)
-        : { ok: false, status: null };
-    return {
-        sandbox_id: sandboxId,
-        port: resolvedPort,
-        preview_url: previewUrl,
-        preview_ready: edge.ok,
-        internal_status: internal.status,
-        edge_status: edge.status,
-        latency_ms: edge.latency_ms ?? null,
-    };
 }
 const NON_TERMINAL_DEPLOY_STATES = new Set([
     "building",
@@ -2011,10 +2035,123 @@ function createDeployArchive(sourceDir) {
     return archivePath;
 }
 async function uploadFileToSandbox(c, sandboxId, localPath, remotePath) {
-    await c.apiPost(apiPath(`/sandboxes/${enc(sandboxId)}/files`), {
-        path: remotePath,
-        content: fs.readFileSync(localPath).toString("base64"),
-    });
+    return writeBytesToSandbox(c, sandboxId, remotePath, fs.readFileSync(localPath));
+}
+async function writeBytesToSandbox(c, sandboxId, remotePath, bytes) {
+    try {
+        return await c.apiPost(apiPath(`/sandboxes/${enc(sandboxId)}/files`), {
+            path: remotePath,
+            content: bytes.toString("base64"),
+        });
+    }
+    catch (err) {
+        if (!shouldFallbackSandboxUpload(err))
+            throw err;
+        await writeBytesToSandboxViaExec(c, sandboxId, remotePath, bytes);
+        return {
+            data: {
+                sandbox_id: sandboxId,
+                path: remotePath,
+                size: bytes.length,
+                transport: "exec_chunked_fallback",
+            },
+        };
+    }
+}
+async function writeBytesToSandboxViaExec(c, sandboxId, remotePath, bytes) {
+    const base64 = bytes.toString("base64");
+    const base64Path = `${remotePath}.b64`;
+    const chunkSize = 48_000;
+    await execSandbox(c, sandboxId, `mkdir -p ${shellQuote(path.posix.dirname(remotePath))} && rm -f ${shellQuote(remotePath)} ${shellQuote(base64Path)}`, "/");
+    for (let offset = 0; offset < base64.length; offset += chunkSize) {
+        const chunk = base64.slice(offset, offset + chunkSize);
+        await execSandbox(c, sandboxId, `printf '%s' ${shellQuote(chunk)} >> ${shellQuote(base64Path)}`, "/");
+    }
+    await execSandbox(c, sandboxId, `base64 -d ${shellQuote(base64Path)} > ${shellQuote(remotePath)} && rm -f ${shellQuote(base64Path)}`, "/");
+}
+function shouldFallbackSandboxUpload(err) {
+    if (err instanceof NetworkError || err instanceof ServerError)
+        return true;
+    if (err instanceof ApiResponseError) {
+        return (err.retryable ||
+            /AGENT_UNAVAILABLE|SANDBOX_FILE_AGENT_UNAVAILABLE/i.test(err.code));
+    }
+    if (err instanceof Error) {
+        return /fetch failed|ECONNRESET|HTTP 502|AGENT_UNAVAILABLE/i.test(err.message);
+    }
+    return false;
+}
+function recoveryCommandForSandboxDeploy(sandboxId, opts, localDir) {
+    const parts = [
+        "miosa",
+        "sandbox",
+        "deploy",
+        shellQuote(localDir),
+        "--sandbox",
+        shellQuote(sandboxId),
+    ];
+    if (opts.port != null)
+        parts.push("--port", String(opts.port));
+    if (opts.publishPort != null)
+        parts.push("--publish-port", String(opts.publishPort));
+    if (opts.installCommand)
+        parts.push("--install-command", shellQuote(opts.installCommand));
+    if (opts.install === false)
+        parts.push("--no-install");
+    if (opts.start)
+        parts.push("--start", shellQuote(opts.start));
+    if (opts.wait)
+        parts.push("--wait");
+    if (opts.timeout != null)
+        parts.push("--timeout", `${opts.timeout}s`);
+    if (opts.probePath)
+        parts.push("--probe-path", shellQuote(opts.probePath));
+    return parts.join(" ");
+}
+function handleSandboxDeployError(err, opts) {
+    if (err instanceof SandboxDeployPartialError) {
+        const cause = err.causeError;
+        const message = cause instanceof Error ? cause.message : String(cause);
+        const retryable = cause instanceof ApiResponseError
+            ? cause.retryable
+            : shouldFallbackSandboxUpload(cause);
+        if (isJsonMode(opts)) {
+            console.log(JSON.stringify({
+                ok: false,
+                error: {
+                    code: errorCodeForDeployCause(cause),
+                    message,
+                    retryable,
+                    ...(cause instanceof MiosaError && cause.requestId
+                        ? { request_id: cause.requestId }
+                        : {}),
+                },
+                partial_resource: {
+                    type: "sandbox",
+                    id: err.sandboxId,
+                    recovery_command: err.recoveryCommand,
+                },
+            }, null, 2));
+            return process.exit(1);
+        }
+        console.error(chalk.red(`Error: ${message}`));
+        console.error(chalk.yellow(`Sandbox ${err.sandboxId} exists. Retry into it with:\n  ${err.recoveryCommand}`));
+        return process.exit(1);
+    }
+    handleError(err);
+}
+function errorCodeForDeployCause(err) {
+    if (err instanceof ApiResponseError)
+        return err.code;
+    if (err instanceof NetworkError)
+        return "NETWORK";
+    if (err instanceof ServerError)
+        return "SERVER";
+    if (err instanceof MiosaError)
+        return err.constructor.name.toUpperCase();
+    if (err instanceof Error && /fetch failed|ECONNRESET/i.test(err.message))
+        return "NETWORK";
+    return "UNEXPECTED_ERROR";
 }
 async function uploadDirToSandbox(sandboxId, localDir, remoteDir, opts) {
     const sourceDir = path.resolve(localDir);