npm - @enter-pro/enter-cli - Versions diffs - 0.4.1 → 0.4.3 - Mend

@enter-pro/enter-cli 0.4.1 → 0.4.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (35) hide show

package/README.md +167 -0
package/dist/auth.d.ts +4 -0
package/dist/auth.js +132 -6
package/dist/client.d.ts +4 -6
package/dist/client.js +97 -93
package/dist/commands/config.js +5 -10
package/dist/commands/domain.js +3 -6
package/dist/commands/login.js +18 -12
package/dist/commands/logout.js +7 -3
package/dist/commands/project.js +85 -70
package/dist/commands/thread-tasks.d.ts +2 -0
package/dist/commands/thread-tasks.js +23 -0
package/dist/commands/thread.d.ts +54 -0
package/dist/commands/thread.js +547 -209
package/dist/commands/whoami.js +1 -1
package/dist/commands/workspace.js +7 -10
package/dist/config.d.ts +0 -1
package/dist/config.js +10 -4
package/dist/errors.d.ts +8 -0
package/dist/errors.js +29 -0
package/dist/index.js +9 -2
package/dist/output.d.ts +0 -16
package/dist/output.js +0 -18
package/dist/poll.d.ts +1 -0
package/dist/poll.js +3 -1
package/dist/safe-output.d.ts +6 -0
package/dist/safe-output.js +29 -0
package/dist/thread-events.d.ts +37 -0
package/dist/thread-events.js +196 -0
package/dist/workflow.d.ts +44 -0
package/dist/workflow.js +34 -0
package/package.json +22 -10
package/scripts/install-hosts.mjs +29 -0
package/skills/enter/SKILL.md +36 -0
package/skills/enter/references/configuration.md +19 -0

package/dist/commands/login.js CHANGED Viewed

@@ -2,12 +2,12 @@ import { Command } from "commander";
 import { createServer } from "http";
 import { randomBytes, createHash } from "crypto";
 import { execSync } from "child_process";
-import { saveCredentials } from "../auth.js";
-import { printMessage } from "../output.js";
-const AUTH0_DOMAIN = "auth.enter.pro";
-const CLIENT_ID = "TZvnfnosSwQh9UmOTxmcWiIJ7CqFrsln";
+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 = 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";
@@ -83,6 +83,7 @@ function startOAuthFlow() {
             }
             try {
                 const tokens = await exchangeCodeForTokens(code, codeVerifier);
+                await verifyAccessToken(tokens.access_token);
                 const expiresAt = new Date(Date.now() + tokens.expires_in * 1000).toISOString();
                 saveCredentials({
                     access_token: tokens.access_token,
@@ -93,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();
@@ -117,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(() => {
@@ -130,14 +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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,8 +1,12 @@
+import { setTimeout as delay } from "node:timers/promises";
 import { Command } from "commander";
 import { writeFileSync } from "fs";
 import * as client from "../client.js";
 import { print, printMessage, printResult, printTable, pickList, getFormat } from "../output.js";
 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")
@@ -61,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") {
@@ -69,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
@@ -89,6 +94,9 @@ projectCmd
     .option("--wait", "Wait until the first build completes")
     .option("--timeout <seconds>", "Timeout for --wait in seconds", "300")
     .action(async (id, opts, cmd) => {
+    const seconds = Number(opts.timeout);
+    if (opts.wait && (!Number.isFinite(seconds) || seconds <= 0 || seconds * 1000 > 2147483647))
+        throw new Error("--timeout must be a positive bounded number");
     const body = {};
     if (opts.name)
         body.name = opts.name;
@@ -99,38 +107,15 @@ projectCmd
     if (opts.planMode)
         body.plan_mode = true;
     const data = await client.post(`/v1/workspaces/${id}/projects`, body);
-    if (!opts.wait) {
-        print(getFormat(cmd), data);
-        return;
-    }
-    const created = data;
+    const created = unwrapProject(data);
     const projectId = String(created.project_id ?? created.id ?? "");
-    if (!projectId) {
-        print(getFormat(cmd), data);
+    if (!projectId)
+        throw new Error("Creation response is missing project ID; creation outcome is unknown. Inspect project list before retrying.");
+    if (!opts.wait) {
+        print(getFormat(cmd), safeOutput({ ...data, submission_status: "accepted", ...threadInteraction(projectId) }));
         return;
     }
-    console.error("Waiting for first build to complete...");
-    const timeoutMs = parseInt(opts.timeout, 10) * 1000;
-    const buildingStatuses = new Set(["initializing", "building"]);
-    try {
-        const result = await pollUntil(() => client.get(`/v1/projects/${projectId}/detail`), (d) => !buildingStatuses.has(String(d.status ?? "")), {
-            intervalMs: 3000,
-            timeoutMs,
-            onTick: (elapsed) => {
-                process.stderr.write(`\rWaiting... ${Math.round(elapsed / 1000)}s elapsed`);
-            },
-        });
-        process.stderr.write("\n");
-        const enriched = { ...result, lifecycle_status: resolveLifecycleStatus(result) };
-        print(getFormat(cmd), enriched);
-    }
-    catch (err) {
-        if (err instanceof TimeoutError) {
-            console.error(`\nTimed out after ${opts.timeout}s. Project may still be building.`);
-            process.exit(1);
-        }
-        throw err;
-    }
+    await reportThread(projectId, { timeout: String(seconds), requireBuild: true, compact: true }, cmd, true);
 });
 projectCmd
     .command("rename <project_id> <new_name>")
@@ -150,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;
 }
@@ -294,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);
 });
@@ -411,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-tasks.d.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ import type { Command } from "commander";
2	+ export declare function registerThreadTasks(parent: Command): void;

package/dist/commands/thread-tasks.js ADDED Viewed

@@ -0,0 +1,23 @@
+import * as client from "../client.js";
+import { getFormat, print, printTable } from "../output.js";
+// Queue payloads can contain prompts, attachments and credentials. Expose only
+// the metadata needed to diagnose accepted tasks that have no turn yet.
+export function registerThreadTasks(parent) {
+    parent.command("tasks <project_id>")
+        .description("List queued/running tasks without exposing prompts or credentials")
+        .option("--chat-id <id>", "Scope the queue lookup to a chat")
+        .action(async (projectId, opts, cmd) => {
+        const data = await client.get(`/v1/projects/${projectId}/thread/tasks`, opts.chatId ? { chat_id: opts.chatId } : undefined);
+        if (!Array.isArray(data?.tasks))
+            throw new Error("Invalid task queue response: expected tasks array");
+        const tasks = data.tasks.map(task => Object.fromEntries(["id", "task_type", "task_status", "created_at", "project_id", "chat_id"]
+            .filter(key => typeof task[key] === "string")
+            .map(key => [key, task[key]])));
+        if (getFormat(cmd) === "table") {
+            printTable(["ID", "Type", "Status", "Created", "Chat"], tasks.map(task => ["id", "task_type", "task_status", "created_at", "chat_id"].map(key => String(task[key] ?? ""))));
+        }
+        else {
+            print(getFormat(cmd), { project_id: projectId, ...(opts.chatId ? { chat_id: opts.chatId } : {}), tasks, total: tasks.length });
+        }
+    });
+}

package/dist/commands/thread.d.ts CHANGED Viewed

@@ -1,2 +1,56 @@
 import { Command } from "commander";
 export declare const threadCmd: Command;
+type InteractionOptions = {
+    taskId?: string;
+    chatId?: string;
+    turn?: number;
+    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;
+    status_command: string;
+    follow_up_command: string;
+    instructions: string;
+};
+type MonitorOptions = {
+    turn?: string;
+    taskId?: string;
+    chatId?: string;
+    cursor?: string;
+    timeout: string;
+    transport?: string;
+    full?: boolean;
+    compact?: boolean;
+    requireBuild?: boolean;
+};
+export declare function reportThread(id: string, opts: MonitorOptions, cmd: Command, wait: boolean, watch?: boolean): Promise<void>;
+export {};