@insforge/cli 0.1.18 → 0.1.20

package/dist/index.js

@@ -5,7 +5,7 @@ import { readFileSync as readFileSync6 } from "fs";
 import { join as join6, dirname } from "path";
 import { fileURLToPath } from "url";
 import { Command } from "commander";
-import * as clack13 from "@clack/prompts";
+import * as clack14 from "@clack/prompts";
 
 // src/lib/config.ts
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
@@ -694,6 +694,21 @@ ${missing.join("\n")}
 `;
   appendFileSync(gitignorePath, block);
 }
+async function installCliGlobally(json) {
+  try {
+    const { stdout } = await execAsync("npm ls -g @insforge/cli --json", { timeout: 1e4 });
+    const parsed = JSON.parse(stdout);
+    if (parsed?.dependencies?.["@insforge/cli"]) return;
+  } catch {
+  }
+  try {
+    if (!json) clack5.log.info("Installing InsForge CLI globally...");
+    await execAsync("npm install -g @insforge/cli", { timeout: 6e4 });
+    if (!json) clack5.log.success("InsForge CLI installed. You can now run `insforge` directly.");
+  } catch {
+    if (!json) clack5.log.warn("Failed to install CLI globally. You can run manually: npm install -g @insforge/cli");
+  }
+}
 async function installSkills(json) {
   try {
     if (!json) clack5.log.info("Installing InsForge agent skills...");
@@ -818,6 +833,7 @@ function registerProjectLinkCommand(program2) {
       } else {
         outputSuccess(`Linked to project "${project.name}" (${project.appkey}.${project.region})`);
       }
+      await installCliGlobally(json);
       await installSkills(json);
       await reportCliUsage("cli.link", true, 6);
     } catch (err) {
@@ -1383,23 +1399,42 @@ Specify --file <path> or create ${join3("insforge", "functions", slug, "index.ts
       } catch {
         exists = false;
       }
+      let res;
       if (exists) {
-        await ossFetch(`/api/functions/${encodeURIComponent(slug)}`, {
+        res = await ossFetch(`/api/functions/${encodeURIComponent(slug)}`, {
           method: "PUT",
           body: JSON.stringify({ name, description, code })
         });
       } else {
-        await ossFetch("/api/functions", {
+        res = await ossFetch("/api/functions", {
           method: "POST",
           body: JSON.stringify({ slug, name, description, code })
         });
       }
+      const result = await res.json();
+      const deployFailed = result.deployment?.status === "failed";
       if (json) {
-        outputJson({ success: true, slug, action: exists ? "updated" : "created" });
+        outputJson(result);
       } else {
-        outputSuccess(`Function "${slug}" ${exists ? "updated" : "created"} successfully.`);
+        const action = exists ? "updation" : "creation";
+        const resultStatus = result.success ? "success" : "failed";
+        outputSuccess(`Function "${result.function.slug}" ${action} ${resultStatus}.`);
+        if (result.deployment) {
+          if (result.deployment.status === "success") {
+            console.log(`  Deployment: ${result.deployment.status}${result.deployment.url ? ` \u2192 ${result.deployment.url}` : ""}`);
+          } else {
+            console.log(`  Deployment: ${result.deployment.status}`);
+            if (result.deployment.buildLogs?.length) {
+              console.log("  Build logs:");
+              for (const line of result.deployment.buildLogs) {
+                console.log(`    ${line}`);
+              }
+            }
+          }
+        }
       }
-      await reportCliUsage("cli.functions.deploy", true);
+      await reportCliUsage("cli.functions.deploy", !deployFailed);
+      if (deployFailed) process.exit(1);
     } catch (err) {
       await reportCliUsage("cli.functions.deploy", false);
       handleError(err, json);
@@ -1480,6 +1515,43 @@ function registerFunctionsCodeCommand(functionsCmd2) {
   });
 }
 
+// src/commands/functions/delete.ts
+import * as clack7 from "@clack/prompts";
+function registerFunctionsDeleteCommand(functionsCmd2) {
+  functionsCmd2.command("delete <slug>").description("Delete an edge function").action(async (slug, _opts, cmd) => {
+    const { json, yes } = getRootOpts(cmd);
+    try {
+      await requireAuth();
+      if (!yes && !json) {
+        const confirmed = await clack7.confirm({
+          message: `Delete function "${slug}"? This cannot be undone.`
+        });
+        if (clack7.isCancel(confirmed) || !confirmed) {
+          clack7.log.info("Cancelled.");
+          return;
+        }
+      }
+      const res = await ossFetch(`/api/functions/${encodeURIComponent(slug)}`, {
+        method: "DELETE"
+      });
+      const result = await res.json();
+      if (json) {
+        outputJson(result);
+      } else {
+        if (result.success) {
+          outputSuccess(`Function "${slug}" deleted successfully.`);
+        } else {
+          outputSuccess(`Failed to delete function "${slug}".`);
+        }
+      }
+      await reportCliUsage("cli.functions.delete", true);
+    } catch (err) {
+      await reportCliUsage("cli.functions.delete", false);
+      handleError(err, json);
+    }
+  });
+}
+
 // src/commands/storage/buckets.ts
 function registerStorageBucketsCommand(storageCmd2) {
   storageCmd2.command("buckets").description("List all storage buckets").action(async (_opts, cmd) => {
@@ -1613,17 +1685,17 @@ function registerStorageCreateBucketCommand(storageCmd2) {
 }
 
 // src/commands/storage/delete-bucket.ts
-import * as clack7 from "@clack/prompts";
+import * as clack8 from "@clack/prompts";
 function registerStorageDeleteBucketCommand(storageCmd2) {
   storageCmd2.command("delete-bucket <name>").description("Delete a storage bucket and all its objects").action(async (name, _opts, cmd) => {
     const { json, yes } = getRootOpts(cmd);
     try {
       await requireAuth();
       if (!yes && !json) {
-        const confirm7 = await clack7.confirm({
+        const confirm8 = await clack8.confirm({
           message: `Delete bucket "${name}" and all its objects? This cannot be undone.`
         });
-        if (!confirm7 || clack7.isCancel(confirm7)) {
+        if (!confirm8 || clack8.isCancel(confirm8)) {
           process.exit(0);
         }
       }
@@ -1705,12 +1777,12 @@ import { tmpdir } from "os";
 import { promisify as promisify2 } from "util";
 import * as fs2 from "fs/promises";
 import * as path2 from "path";
-import * as clack9 from "@clack/prompts";
+import * as clack10 from "@clack/prompts";
 
 // src/commands/deployments/deploy.ts
 import * as path from "path";
 import * as fs from "fs/promises";
-import * as clack8 from "@clack/prompts";
+import * as clack9 from "@clack/prompts";
 import archiver from "archiver";
 var POLL_INTERVAL_MS = 5e3;
 var POLL_TIMEOUT_MS = 12e4;
@@ -1814,7 +1886,7 @@ function registerDeploymentsDeployCommand(deploymentsCmd2) {
       if (!stats?.isDirectory()) {
         throw new CLIError(`"${sourceDir}" is not a valid directory.`);
       }
-      const s = !json ? clack8.spinner() : null;
+      const s = !json ? clack9.spinner() : null;
       const startBody = {};
       if (opts.env) {
         try {
@@ -1842,18 +1914,18 @@ function registerDeploymentsDeployCommand(deploymentsCmd2) {
           outputJson(result.deployment);
         } else {
           if (result.liveUrl) {
-            clack8.log.success(`Live at: ${result.liveUrl}`);
+            clack9.log.success(`Live at: ${result.liveUrl}`);
           }
-          clack8.log.info(`Deployment ID: ${result.deploymentId}`);
+          clack9.log.info(`Deployment ID: ${result.deploymentId}`);
         }
       } else {
         s?.stop("Deployment is still building");
         if (json) {
           outputJson({ id: result.deploymentId, status: result.deployment?.status ?? "building", timedOut: true });
         } else {
-          clack8.log.info(`Deployment ID: ${result.deploymentId}`);
-          clack8.log.warn("Deployment did not finish within 2 minutes.");
-          clack8.log.info(`Check status with: insforge deployments status ${result.deploymentId}`);
+          clack9.log.info(`Deployment ID: ${result.deploymentId}`);
+          clack9.log.warn("Deployment did not finish within 2 minutes.");
+          clack9.log.info(`Check status with: insforge deployments status ${result.deploymentId}`);
         }
       }
       await reportCliUsage("cli.deployments.deploy", true);
@@ -1897,7 +1969,7 @@ function registerCreateCommand(program2) {
     try {
       await requireAuth(apiUrl);
       if (!json) {
-        clack9.intro("Create a new InsForge project");
+        clack10.intro("Create a new InsForge project");
       }
       let orgId = opts.orgId;
       if (!orgId) {
@@ -1908,14 +1980,14 @@ function registerCreateCommand(program2) {
         if (json) {
           throw new CLIError("Specify --org-id in JSON mode.");
         }
-        const selected = await clack9.select({
+        const selected = await clack10.select({
           message: "Select an organization:",
           options: orgs.map((o) => ({
             value: o.id,
             label: o.name
           }))
         });
-        if (clack9.isCancel(selected)) process.exit(0);
+        if (clack10.isCancel(selected)) process.exit(0);
         orgId = selected;
       }
       const globalConfig = getGlobalConfig();
@@ -1924,11 +1996,11 @@ function registerCreateCommand(program2) {
       let projectName = opts.name;
       if (!projectName) {
         if (json) throw new CLIError("--name is required in JSON mode.");
-        const name = await clack9.text({
+        const name = await clack10.text({
           message: "Project name:",
           validate: (v) => v.length >= 2 ? void 0 : "Name must be at least 2 characters"
         });
-        if (clack9.isCancel(name)) process.exit(0);
+        if (clack10.isCancel(name)) process.exit(0);
         projectName = name;
       }
       let template = opts.template;
@@ -1936,7 +2008,7 @@ function registerCreateCommand(program2) {
         if (json) {
           template = "empty";
         } else {
-          const selected = await clack9.select({
+          const selected = await clack10.select({
             message: "Choose a starter template:",
             options: [
               { value: "react", label: "Web app template with React" },
@@ -1944,11 +2016,11 @@ function registerCreateCommand(program2) {
               { value: "empty", label: "Empty project" }
             ]
           });
-          if (clack9.isCancel(selected)) process.exit(0);
+          if (clack10.isCancel(selected)) process.exit(0);
           template = selected;
         }
       }
-      const s = !json ? clack9.spinner() : null;
+      const s = !json ? clack10.spinner() : null;
       s?.start("Creating project...");
       const project = await createProject(orgId, projectName, opts.region, apiUrl);
       s?.message("Waiting for project to become active...");
@@ -1969,10 +2041,11 @@ function registerCreateCommand(program2) {
       if (hasTemplate) {
         await downloadTemplate(template, projectConfig, projectName, json, apiUrl);
       }
+      await installCliGlobally(json);
       await installSkills(json);
       await reportCliUsage("cli.create", true, 6);
       if (hasTemplate) {
-        const installSpinner = !json ? clack9.spinner() : null;
+        const installSpinner = !json ? clack10.spinner() : null;
         installSpinner?.start("Installing dependencies...");
         try {
           await execAsync2("npm install", { cwd: process.cwd(), maxBuffer: 10 * 1024 * 1024 });
@@ -1980,19 +2053,19 @@ function registerCreateCommand(program2) {
         } catch (err) {
           installSpinner?.stop("Failed to install dependencies");
           if (!json) {
-            clack9.log.warn(`npm install failed: ${err.message}`);
-            clack9.log.info("Run `npm install` manually to install dependencies.");
+            clack10.log.warn(`npm install failed: ${err.message}`);
+            clack10.log.info("Run `npm install` manually to install dependencies.");
           }
         }
       }
       let liveUrl = null;
       if (hasTemplate && !json) {
-        const shouldDeploy = await clack9.confirm({
+        const shouldDeploy = await clack10.confirm({
           message: "Would you like to deploy now?"
         });
-        if (!clack9.isCancel(shouldDeploy) && shouldDeploy) {
+        if (!clack10.isCancel(shouldDeploy) && shouldDeploy) {
           try {
-            const deploySpinner = clack9.spinner();
+            const deploySpinner = clack10.spinner();
             const result = await deployProject({
               sourceDir: process.cwd(),
               spinner: deploySpinner
@@ -2002,12 +2075,12 @@ function registerCreateCommand(program2) {
               liveUrl = result.liveUrl;
             } else {
               deploySpinner.stop("Deployment is still building");
-              clack9.log.info(`Deployment ID: ${result.deploymentId}`);
-              clack9.log.warn("Deployment did not finish within 2 minutes.");
-              clack9.log.info(`Check status with: insforge deployments status ${result.deploymentId}`);
+              clack10.log.info(`Deployment ID: ${result.deploymentId}`);
+              clack10.log.warn("Deployment did not finish within 2 minutes.");
+              clack10.log.info(`Check status with: insforge deployments status ${result.deploymentId}`);
             }
           } catch (err) {
-            clack9.log.warn(`Deploy failed: ${err.message}`);
+            clack10.log.warn(`Deploy failed: ${err.message}`);
           }
         }
       }
@@ -2023,11 +2096,11 @@ function registerCreateCommand(program2) {
           }
         });
       } else {
-        clack9.log.step(`Dashboard: ${dashboardUrl}`);
+        clack10.log.step(`Dashboard: ${dashboardUrl}`);
         if (liveUrl) {
-          clack9.log.success(`Live site: ${liveUrl}`);
+          clack10.log.success(`Live site: ${liveUrl}`);
         }
-        clack9.outro("Done!");
+        clack10.outro("Done!");
       }
     } catch (err) {
       handleError(err, json);
@@ -2035,7 +2108,7 @@ function registerCreateCommand(program2) {
   });
 }
 async function downloadTemplate(framework, projectConfig, projectName, json, _apiUrl) {
-  const s = !json ? clack9.spinner() : null;
+  const s = !json ? clack10.spinner() : null;
   s?.start("Downloading template...");
   try {
     const anonKey = await getAnonKey();
@@ -2066,8 +2139,8 @@ async function downloadTemplate(framework, projectConfig, projectName, json, _ap
   } catch (err) {
     s?.stop("Template download failed");
     if (!json) {
-      clack9.log.warn(`Failed to download template: ${err.message}`);
-      clack9.log.info("You can manually set up the template later.");
+      clack10.log.warn(`Failed to download template: ${err.message}`);
+      clack10.log.info("You can manually set up the template later.");
     }
   }
 }
@@ -2250,7 +2323,7 @@ function registerDeploymentsStatusCommand(deploymentsCmd2) {
 }
 
 // src/commands/deployments/cancel.ts
-import * as clack10 from "@clack/prompts";
+import * as clack11 from "@clack/prompts";
 function registerDeploymentsCancelCommand(deploymentsCmd2) {
   deploymentsCmd2.command("cancel <id>").description("Cancel a deployment").action(async (id, _opts, cmd) => {
     const { json, yes } = getRootOpts(cmd);
@@ -2258,10 +2331,10 @@ function registerDeploymentsCancelCommand(deploymentsCmd2) {
       await requireAuth();
       if (!getProjectConfig()) throw new ProjectNotLinkedError();
       if (!yes && !json) {
-        const confirmed = await clack10.confirm({
+        const confirmed = await clack11.confirm({
           message: `Cancel deployment ${id}?`
         });
-        if (clack10.isCancel(confirmed) || !confirmed) process.exit(0);
+        if (clack11.isCancel(confirmed) || !confirmed) process.exit(0);
       }
       const res = await ossFetch(`/api/deployments/${id}/cancel`, { method: "POST" });
       const result = await res.json();
@@ -2464,17 +2537,17 @@ function registerSecretsUpdateCommand(secretsCmd2) {
 }
 
 // src/commands/secrets/delete.ts
-import * as clack11 from "@clack/prompts";
+import * as clack12 from "@clack/prompts";
 function registerSecretsDeleteCommand(secretsCmd2) {
   secretsCmd2.command("delete <key>").description("Delete a secret").action(async (key, _opts, cmd) => {
     const { json, yes } = getRootOpts(cmd);
     try {
       await requireAuth();
       if (!yes && !json) {
-        const confirm7 = await clack11.confirm({
+        const confirm8 = await clack12.confirm({
           message: `Delete secret "${key}"? This cannot be undone.`
         });
-        if (!confirm7 || clack11.isCancel(confirm7)) {
+        if (!confirm8 || clack12.isCancel(confirm8)) {
           process.exit(0);
         }
       }
@@ -2650,17 +2723,17 @@ function registerSchedulesUpdateCommand(schedulesCmd2) {
 }
 
 // src/commands/schedules/delete.ts
-import * as clack12 from "@clack/prompts";
+import * as clack13 from "@clack/prompts";
 function registerSchedulesDeleteCommand(schedulesCmd2) {
   schedulesCmd2.command("delete <id>").description("Delete a schedule").action(async (id, _opts, cmd) => {
     const { json, yes } = getRootOpts(cmd);
     try {
       await requireAuth();
       if (!yes && !json) {
-        const confirm7 = await clack12.confirm({
+        const confirm8 = await clack13.confirm({
           message: `Delete schedule "${id}"? This cannot be undone.`
         });
-        if (!confirm7 || clack12.isCancel(confirm7)) {
+        if (!confirm8 || clack13.isCancel(confirm8)) {
           process.exit(0);
         }
       }
@@ -2889,6 +2962,7 @@ registerFunctionsCommands(functionsCmd);
 registerFunctionsCodeCommand(functionsCmd);
 registerFunctionsDeployCommand(functionsCmd);
 registerFunctionsInvokeCommand(functionsCmd);
+registerFunctionsDeleteCommand(functionsCmd);
 var storageCmd = program.command("storage").description("Manage storage");
 registerStorageBucketsCommand(storageCmd);
 registerStorageCreateBucketCommand(storageCmd);
@@ -2933,7 +3007,7 @@ async function showInteractiveMenu() {
   } catch {
   }
   console.log(INSFORGE_LOGO);
-  clack13.intro(`InsForge CLI v${pkg.version}`);
+  clack14.intro(`InsForge CLI v${pkg.version}`);
   const options = [];
   if (!isLoggedIn) {
     options.push({ value: "login", label: "Log in to InsForge" });
@@ -2949,12 +3023,12 @@ async function showInteractiveMenu() {
     { value: "docs", label: "View documentation" },
     { value: "help", label: "Show all commands" }
   );
-  const action = await clack13.select({
+  const action = await clack14.select({
     message: "What would you like to do?",
     options
   });
-  if (clack13.isCancel(action)) {
-    clack13.cancel("Bye!");
+  if (clack14.isCancel(action)) {
+    clack14.cancel("Bye!");
     process.exit(0);
   }
   switch (action) {