@enter-pro/enter-cli 0.4.2 → 0.4.3

package/dist/client.js

@@ -1,5 +1,5 @@
 import { baseURL, workURL } from "./config.js";
-import { getToken } from "./auth.js";
+import { getValidToken } from "./auth.js";
 import { safeOutput } from "./safe-output.js";
 import { APIError, RequestError } from "./errors.js";
 import { setTimeout as delay } from "node:timers/promises";
@@ -24,9 +24,6 @@ async function request(method, path, options, base) {
     const headers = {
         "Content-Type": "application/json",
     };
-    const token = getToken();
-    if (token)
-        headers["Authorization"] = `Bearer ${token}`;
     const init = { method, headers, signal: options?.signal };
     if (options?.body !== undefined) {
         init.body = JSON.stringify(options.body);
@@ -48,11 +45,17 @@ async function request(method, path, options, base) {
     const timer = requestTimeoutMs === undefined ? undefined : setTimeout(() => controller.abort(), requestTimeoutMs);
     init.signal = controller.signal;
     try {
+        const token = await getValidToken(controller.signal);
+        if (token)
+            headers["Authorization"] = `Bearer ${token}`;
         for (let attempt = 0;; attempt++) {
             let resp;
             let text;
             try {
                 resp = await fetch(url, init);
+                if (options?.raw && resp.ok && !resp.headers.get("content-type")?.includes("application/json")) {
+                    return await resp.arrayBuffer();
+                }
                 text = await resp.text();
             }
             catch (error) {
@@ -70,7 +73,7 @@ async function request(method, path, options, base) {
                 console.error(`< ${resp.status} ${resp.statusText}`);
             }
             if (resp.status === 401) {
-                throw new Error("Authentication required. Run `enter login` or set ENTER_API_KEY environment variable.");
+                throw new Error("Authentication required. Run `enter-cli login` or set ENTER_API_KEY environment variable.");
             }
             if (retryRead && [502, 503, 504].includes(resp.status) && attempt < 1) {
                 await delay(200, undefined, { signal: controller.signal });
@@ -92,6 +95,8 @@ async function request(method, path, options, base) {
                 if (resp.status >= 400) {
                     throw new RequestError(`HTTP_${resp.status}`, `Enter returned HTTP ${resp.status}.`, readOnly && resp.status >= 500, !readOnly && resp.status >= 500);
                 }
+                if (options?.raw)
+                    throw new RequestError("INVALID_RESPONSE", "Expected a binary download, but Enter returned JSON.", true);
                 return apiResp;
             }
             if (resp.status >= 500)
@@ -99,6 +104,8 @@ async function request(method, path, options, base) {
             if (apiResp.code !== CODE_SUCCESS) {
                 throw new APIError(apiResp.code, apiResp.message ?? "", apiResp.detail ?? "");
             }
+            if (options?.raw)
+                throw new RequestError("INVALID_RESPONSE", "Expected a binary download, but Enter returned JSON.", true);
             return apiResp.data;
         }
     }
@@ -122,9 +129,6 @@ export async function post(path, body, signal) {
 export async function del(path) {
     return request("DELETE", path);
 }
-export async function put(path, body) {
-    return request("PUT", path, { body });
-}
 export async function patch(path, body) {
     return request("PATCH", path, { body });
 }
@@ -135,60 +139,6 @@ export async function workGet(path, params) {
 export async function workPost(path, body) {
     return request("POST", path, { body }, workURL());
 }
-export async function workPatch(path, body) {
-    return request("PATCH", path, { body }, workURL());
-}
-export async function workDel(path) {
-    return request("DELETE", path, {}, workURL());
-}
 export async function getRaw(path) {
-    const url = `${baseURL()}${path}`;
-    const headers = {};
-    const token = getToken();
-    if (token)
-        headers["Authorization"] = `Bearer ${token}`;
-    if (verbose)
-        console.error(`> GET ${url}`);
-    const resp = await fetch(url, { headers });
-    if (verbose)
-        console.error(`< ${resp.status} ${resp.statusText}`);
-    if (resp.status === 401) {
-        throw new Error("Authentication required. Run `enter login` or set ENTER_API_KEY environment variable.");
-    }
-    // Successful binary response — caller consumes the body.
-    if (resp.ok) {
-        // But: a JSON error envelope can come back with status 200 too. Peek the
-        // content-type; only treat as raw if it's not JSON.
-        const ct = resp.headers.get("content-type") ?? "";
-        if (!ct.includes("application/json"))
-            return resp;
-        const text = await resp.text();
-        try {
-            const apiResp = JSON.parse(text);
-            if (apiResp.code !== 0) {
-                throw new APIError(apiResp.code, apiResp.message, apiResp.detail);
-            }
-            // code === 0 with JSON body on a binary endpoint shouldn't happen; surface as raw text
-            throw new Error(`Unexpected JSON response on binary endpoint: ${text.slice(0, 200)}`);
-        }
-        catch (err) {
-            if (err instanceof APIError)
-                throw err;
-            throw new Error(`Failed to parse JSON response: ${text.slice(0, 200)}`);
-        }
-    }
-    // Non-2xx — try to parse the API error envelope so callers can distinguish
-    // VIP_REQUIRED, NOT_FOUND, etc. Fall back to raw text if it isn't JSON.
-    const text = await resp.text();
-    try {
-        const apiResp = JSON.parse(text);
-        if (apiResp.code !== undefined) {
-            throw new APIError(apiResp.code, apiResp.message ?? "", apiResp.detail ?? "");
-        }
-    }
-    catch (err) {
-        if (err instanceof APIError)
-            throw err;
-    }
-    throw new Error(`HTTP ${resp.status}: ${text || resp.statusText}`);
+    return request("GET", path, { raw: true });
 }

package/dist/commands/config.js

@@ -1,25 +1,20 @@
 import { Command } from "commander";
 import { setConfig, getConfig, allSettings } from "../config.js";
-import { print, printMessage, printTable } from "../output.js";
+import { print, printResult, printTable, getFormat } from "../output.js";
 export const configCmd = new Command("config").description("Manage CLI configuration");
 configCmd
     .command("set <key> <value>")
     .description("Set a configuration value")
-    .action(async (key, value) => {
+    .action(async (key, value, _opts, cmd) => {
     setConfig(key, value);
-    printMessage(`Set ${key} = ${value}`);
+    printResult(getFormat(cmd), { key, value }, `Set ${key} = ${value}`);
 });
 configCmd
     .command("get <key>")
     .description("Get a configuration value")
-    .action(async (key) => {
+    .action(async (key, _opts, cmd) => {
     const val = getConfig(key);
-    if (!val) {
-        printMessage(`${key}: (not set)`);
-    }
-    else {
-        printMessage(`${key}: ${val}`);
-    }
+    printResult(getFormat(cmd), { key, value: val || null }, val ? `${key}: ${val}` : `${key}: (not set)`);
 });
 configCmd
     .command("list")

package/dist/commands/domain.js

@@ -1,10 +1,7 @@
 import { Command } from "commander";
 import * as client from "../client.js";
-import { print, printMessage, printTable } from "../output.js";
+import { print, printResult, printTable, getFormat } from "../output.js";
 export const domainCmd = new Command("domain").description("Manage project domains");
-function getFormat(cmd) {
-    return cmd.optsWithGlobals().output || "json";
-}
 domainCmd
     .command("list <project_id>")
     .description("List project domains")
@@ -37,9 +34,9 @@ domainCmd
     .command("remove <project_id>")
     .description("Remove a custom domain from project")
     .requiredOption("--domain <name>", "Domain name to remove")
-    .action(async (id, opts) => {
+    .action(async (id, opts, cmd) => {
     await client.del(`/v1/projects/${id}/domain?domain=${opts.domain}`);
-    printMessage(`Domain "${opts.domain}" removed.`);
+    printResult(getFormat(cmd), { removed: true, domain: opts.domain }, `Domain "${opts.domain}" removed.`);
 });
 domainCmd
     .command("refresh <project_id>")

package/dist/commands/login.js

@@ -2,12 +2,12 @@ import { Command } from "commander";
 import { createServer } from "http";
 import { randomBytes, createHash } from "crypto";
 import { execSync } from "child_process";
-import { saveCredentials, verifyAccessToken } from "../auth.js";
-import { printMessage } from "../output.js";
+import { saveCredentials, verifyAccessToken, OAUTH_TOKEN_URL, OAUTH_CLIENT_ID } from "../auth.js";
+import { printResult, getFormat } from "../output.js";
 const AUTH0_DOMAIN = "auth.converge.ai";
-const CLIENT_ID = "anCisSaaIA36fTZ2DUMiTMro3bYuptrf";
+const CLIENT_ID = OAUTH_CLIENT_ID;
 const AUTHORIZE_URL = `https://${AUTH0_DOMAIN}/authorize`;
-const TOKEN_URL = `https://${AUTH0_DOMAIN}/oauth/token`;
+const TOKEN_URL = OAUTH_TOKEN_URL;
 const AUDIENCE = "https://api.enter.pro";
 const SCOPE = "openid profile email offline_access";
 const REDIRECT_URI = "http://localhost:19820";
@@ -94,7 +94,6 @@ function startOAuthFlow() {
                 });
                 res.writeHead(200, { "Content-Type": "text/html" });
                 res.end(`<html><body><h2>Login Successful!</h2><p>You can close this window and return to the terminal.</p></body></html>`);
-                printMessage("Login successful. Credentials saved.");
                 clearTimeout(timeoutId);
                 server.close();
                 resolve();
@@ -118,8 +117,8 @@ function startOAuthFlow() {
                 code_challenge_method: "S256",
             });
             const authUrl = `${AUTHORIZE_URL}?${params}`;
-            printMessage("Opening browser for authentication...");
-            printMessage(`If browser doesn't open, visit:\n${authUrl}\n`);
+            console.error("Opening browser for authentication...");
+            console.error(`If browser doesn't open, visit:\n${authUrl}\n`);
             openBrowser(authUrl);
         });
         timeoutId = setTimeout(() => {
@@ -131,15 +130,20 @@ function startOAuthFlow() {
 export const loginCmd = new Command("login")
     .description("Authenticate with Enter platform")
     .option("--api-key <key>", "Authenticate with a workspace API key instead of OAuth")
-    .action(async (opts) => {
+    .action(async (opts, cmd) => {
     if (opts.apiKey) {
         await verifyAccessToken(opts.apiKey);
         saveCredentials({
             access_token: opts.apiKey,
             token_type: "Bearer",
         });
-        printMessage("API key saved. You are now authenticated.");
-        return;
     }
-    await startOAuthFlow();
+    else {
+        await startOAuthFlow();
+    }
+    const injected = Boolean(process.env.ENTER_API_KEY);
+    const message = injected
+        ? "Local credentials verified and saved. ENTER_API_KEY still takes precedence; this has not switched the active account. Change authentication in the host or unset ENTER_API_KEY to use the saved credentials."
+        : "Login successful. Credentials saved.";
+    printResult(getFormat(cmd), { credentials_saved: true, auth_source: injected ? "environment" : "local", ...(!injected ? { authenticated: true } : {}), message }, message);
 });

package/dist/commands/logout.js

@@ -1,9 +1,13 @@
 import { Command } from "commander";
 import { clearCredentials } from "../auth.js";
-import { printMessage } from "../output.js";
+import { printResult, getFormat } from "../output.js";
 export const logoutCmd = new Command("logout")
     .description("Clear stored credentials")
-    .action(async () => {
+    .action(async (_opts, cmd) => {
     clearCredentials();
-    printMessage("Logged out successfully.");
+    const injected = Boolean(process.env.ENTER_API_KEY);
+    const message = injected
+        ? "Local credentials cleared. ENTER_API_KEY still takes precedence; change or disconnect authentication in the host, or unset it in your shell, to switch accounts."
+        : "Stored credentials cleared. Logged out.";
+    printResult(getFormat(cmd), { logged_out: !injected, local_credentials_cleared: true, auth_source: injected ? "environment" : "none", message }, message);
 });

package/dist/commands/project.js

@@ -1,3 +1,4 @@
+import { setTimeout as delay } from "node:timers/promises";
 import { Command } from "commander";
 import { writeFileSync } from "fs";
 import * as client from "../client.js";
@@ -5,6 +6,7 @@ import { print, printMessage, printResult, printTable, pickList, getFormat } fro
 import { pollUntil, TimeoutError } from "../poll.js";
 import { reportThread, threadInteraction } from "./thread.js";
 import { safeOutput } from "../safe-output.js";
+import { RequestError } from "../errors.js";
 import { resolveLifecycleStatus } from "../lifecycle.js";
 export const projectCmd = new Command("project")
     .alias("proj")
@@ -63,7 +65,8 @@ projectCmd
     .action(async (id, _opts, cmd) => {
     const data = await client.get(`/v1/projects/${id}/detail`);
     const p = data;
-    const lifecycle = resolveLifecycleStatus(p);
+    const project = unwrapProject(p);
+    const lifecycle = resolveLifecycleStatus(project);
     const enriched = { ...p, lifecycle_status: lifecycle };
     const format = getFormat(cmd);
     if (format !== "table") {
@@ -71,14 +74,14 @@ projectCmd
         return;
     }
     printTable(["Project ID", "Name", "Visibility", "Status", "Lifecycle", "Preview URL", "Workspace", "Updated"], [[
-            String(p.project_id ?? ""),
-            String(p.name ?? ""),
-            String(p.visibility ?? ""),
-            String(p.status ?? ""),
+            String(project.project_id ?? ""),
+            String(project.name ?? ""),
+            String(project.visibility ?? ""),
+            String(project.status ?? ""),
             lifecycle,
-            String(p.preview_url ?? ""),
-            String(p.workspace_id ?? ""),
-            String(p.updated_at ?? ""),
+            String(project.preview_url ?? ""),
+            String(project.workspace_id ?? ""),
+            String(project.updated_at ?? ""),
         ]]);
 });
 projectCmd
@@ -132,83 +135,108 @@ projectCmd
     .command("download <project_id>")
     .description("Download project as zip file")
     .option("--out <path>", "Output file path")
-    .action(async (id, opts) => {
+    .action(async (id, opts, cmd) => {
     const data = await client.getRaw(`/v1/projects/${id}/download`);
     const outPath = opts.out || `${id}.zip`;
-    writeFileSync(outPath, Buffer.from(await data.arrayBuffer()));
-    printMessage(`Project downloaded to ${outPath}`);
+    writeFileSync(outPath, Buffer.from(data));
+    printResult(getFormat(cmd), { path: outPath }, `Project downloaded to ${outPath}`);
 });
 projectCmd
     .command("publish <project_id>")
     .description("Publish a project (synchronous: waits for completion and verifies URL)")
     .option("--timeout <seconds>", "Timeout in seconds", "300")
     .action(async (id, opts, cmd) => {
-    const initialDetail = await client.get(`/v1/projects/${id}/detail`);
-    const initialProject = unwrapProject(initialDetail);
-    const buildStatus = initialProject.build_status;
-    const commitId = String(buildStatus?.commit_id ?? initialProject.commit ?? "");
-    if (!commitId) {
-        console.error("Error: project has no committed build yet (build_status.commit_id is empty).");
-        console.error("Wait for the latest turn to finish, then retry.");
-        process.exit(1);
-    }
-    await client.post(`/v1/projects/${id}/publish`);
-    console.error("Waiting for publish to complete...");
-    const timeoutMs = parseInt(opts.timeout, 10) * 1000;
+    const seconds = Number(opts.timeout);
+    if (!Number.isFinite(seconds) || seconds <= 0 || seconds * 1000 > 2147483647)
+        throw new Error("--timeout must be a positive bounded number");
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), seconds * 1000);
+    let submitted = false;
+    let published = false;
     try {
-        const result = await pollUntil(() => client.get(`/v1/projects/${id}/detail`), (d) => {
+        const initialDetail = await client.get(`/v1/projects/${id}/detail`, undefined, controller.signal);
+        const initialProject = unwrapProject(initialDetail);
+        const buildStatus = initialProject.build_status;
+        const commitId = String(buildStatus?.commit_id ?? initialProject.commit ?? "");
+        if (!commitId) {
+            throw new Error("Project has no committed build yet. Wait for the latest turn to finish, then retry.");
+        }
+        const format = getFormat(cmd);
+        const human = format === "table";
+        controller.signal.throwIfAborted();
+        submitted = true;
+        await client.post(`/v1/projects/${id}/publish`, undefined, controller.signal);
+        if (human)
+            console.error("Waiting for publish to complete...");
+        const timeoutMs = seconds * 1000;
+        const result = await pollUntil(() => client.get(`/v1/projects/${id}/detail`, undefined, controller.signal), (d) => {
             const view = readPublishStatus(unwrapProject(d));
             // Done when the latest committed build has been published and nothing is queued.
             return view.lastPublishedCommit === commitId && view.unpublishedChanges === 0;
         }, {
+            signal: controller.signal,
             intervalMs: 3000,
             timeoutMs,
             onTick: (elapsed) => {
-                process.stderr.write(`\rWaiting... ${Math.round(elapsed / 1000)}s elapsed`);
+                if (human)
+                    process.stderr.write(`\rWaiting... ${Math.round(elapsed / 1000)}s elapsed`);
             },
         });
-        process.stderr.write("\n");
+        if (human)
+            process.stderr.write("\n");
+        published = true;
         const project = unwrapProject(result);
         const view = readPublishStatus(project);
         const publishUrl = String(project.publish_url ?? "");
-        const reachable = publishUrl ? await verifyUrlReachable(publishUrl) : false;
-        if (publishUrl && !reachable) {
+        const reachable = publishUrl ? await verifyUrlReachable(publishUrl, 3, 2000, controller.signal) : false;
+        if (human && publishUrl && !reachable) {
             console.error(`Warning: ${publishUrl} did not return 200 within retries. The publish completed server-side but the URL may still be propagating.`);
         }
-        printMessage(`Published commit ${commitId.slice(0, 7)} at ${view.lastPublishedAt}. URL: ${publishUrl}${reachable ? " (200 OK)" : ""}`);
-        print(getFormat(cmd), { ...result, lifecycle_status: resolveLifecycleStatus(project) });
+        if (human)
+            printMessage(`Published commit ${commitId.slice(0, 7)} at ${view.lastPublishedAt}. URL: ${publishUrl}${reachable ? " (200 OK)" : ""}`);
+        print(format, { ...result, lifecycle_status: resolveLifecycleStatus(project), publish_reachable: reachable });
     }
     catch (err) {
-        if (err instanceof TimeoutError) {
-            console.error(`\nTimed out after ${opts.timeout}s. Publish may still be in progress.`);
-            console.error(`Run "proj urls ${id}" to check current status.`);
-            process.exit(1);
+        if (err instanceof TimeoutError || controller.signal.aborted) {
+            throw new RequestError("PUBLISH_TIMEOUT", `Publish observation exceeded its deadline. Check enter-cli project publish-status ${id} before retrying.`, false, submitted && !published);
         }
         throw err;
     }
+    finally {
+        clearTimeout(timer);
+    }
 });
 // HEAD-first URL probe with a small wall-clock budget. Falls back to GET when
 // HEAD isn't allowed (some hosts return 405). Used by `proj publish` (after
 // publish completes) and `proj urls` (to determine the recommended URL).
-async function verifyUrlReachable(url, attempts = 3, perAttemptMs = 2000) {
+async function verifyUrlReachable(url, attempts = 3, perAttemptMs = 2000, signal) {
     for (let i = 0; i < attempts; i++) {
+        signal?.throwIfAborted();
         const ctrl = new AbortController();
+        const abort = () => ctrl.abort();
+        signal?.addEventListener("abort", abort, { once: true });
         const t = setTimeout(() => ctrl.abort(), perAttemptMs);
         try {
             let res = await fetch(url, { method: "HEAD", signal: ctrl.signal });
             // Some hosts reject HEAD (405 / 501) — retry once with GET on this attempt.
             if (res.status === 405 || res.status === 501) {
+                await res.body?.cancel();
                 res = await fetch(url, { method: "GET", signal: ctrl.signal });
             }
-            clearTimeout(t);
+            await res.body?.cancel();
             if (res.status === 200)
                 return true;
         }
         catch {
+            signal?.throwIfAborted();
+        }
+        finally {
+            ctrl.abort();
             clearTimeout(t);
+            signal?.removeEventListener("abort", abort);
         }
         if (i < attempts - 1)
-            await new Promise((r) => setTimeout(r, 1000));
+            await delay(1000, undefined, { signal });
     }
     return false;
 }
@@ -276,8 +304,13 @@ projectCmd
     .option("--workspace-id <id>", "Target workspace ID for remix")
     .action(async (id, opts, cmd) => {
     const body = {};
-    if (opts.workspaceId)
-        body.workspace_id = opts.workspaceId;
+    if (opts.workspaceId !== undefined) {
+        const workspaceId = Number(opts.workspaceId);
+        if (!/^\d+$/.test(opts.workspaceId) || !Number.isSafeInteger(workspaceId) || workspaceId <= 0) {
+            throw new Error("--workspace-id must be a positive safe integer");
+        }
+        body.workspace_id = workspaceId;
+    }
     const data = await client.post(`/v1/projects/${id}/remix`, body);
     print(getFormat(cmd), data);
 });
@@ -393,9 +426,9 @@ mcpCmd
 mcpCmd
     .command("delete <project_id> <server_id>")
     .description("Delete an MCP server")
-    .action(async (id, serverId) => {
+    .action(async (id, serverId, _opts, cmd) => {
     await client.del(`/v1/projects/${id}/mcp/servers/${serverId}`);
-    printMessage(`MCP server ${serverId} deleted.`);
+    printResult(getFormat(cmd), { deleted: true, server_id: serverId }, `MCP server ${serverId} deleted.`);
 });
 projectCmd.addCommand(mcpCmd);
 // Project skills subcommand group

package/dist/commands/thread.d.ts

@@ -7,6 +7,33 @@ type InteractionOptions = {
     requireBuild?: boolean;
 };
 export declare function threadInteraction(id: string, { taskId, chatId, turn, requireBuild }?: InteractionOptions): {
+    workflow: {
+        actions?: {
+            id: unknown;
+            kind: unknown;
+            decision: string;
+            required_fields: {};
+            submit_command: unknown;
+        }[] | undefined;
+        build?: {
+            commit: {} | null;
+            matches_task: boolean;
+            success: {} | null;
+        } | undefined;
+        observation: {
+            timed_out: boolean;
+            retrying: boolean;
+            interrupted: boolean;
+        };
+        reason?: string | undefined;
+        state: string;
+        task: {
+            id: {} | null;
+            turn: {} | null;
+            chat_id: {} | null;
+        };
+        next_action: string;
+    };
     monitoring_required: boolean;
     wait_command: string;
     watch_command: string;