@instafy/cli 0.1.8 → 0.1.9

package/dist/index.js

@@ -4,11 +4,13 @@ import { createRequire } from "node:module";
 import kleur from "kleur";
 import { runtimeStart, runtimeStatus, runtimeStop, runtimeToken, findProjectManifest, } from "./runtime.js";
 import { login, logout } from "./auth.js";
-import { gitToken } from "./git.js";
-import { projectInit } from "./project.js";
-import { runTunnelCommand } from "./tunnel.js";
+import { runGitCredentialHelper } from "./git-credential.js";
+import { projectInit, projectProfile } from "./project.js";
+import { listTunnelSessions, startTunnelDetached, stopTunnelSession, tailTunnelLogs, runTunnelCommand } from "./tunnel.js";
 import { requestControllerApi } from "./api.js";
 import { configGet, configList, configPath, configSet, configUnset } from "./config-command.js";
+import { getInstafyProfileConfigPath, listInstafyProfileNames, readInstafyProfileConfig } from "./config.js";
+import { runInstafyGit, runInstafyGitSync } from "./git-wrapper.js";
 export const program = new Command();
 const require = createRequire(import.meta.url);
 const pkg = require("../package.json");
@@ -39,7 +41,11 @@ program
     .description("Log in and save an access token for future CLI commands")
     .option("--studio-url <url>", "Studio web URL (default: staging or localhost)")
     .option("--server-url <url>", "Instafy server/controller URL")
+    .option("--profile <name>", "Save token under a named profile (multi-account support)")
     .option("--token <token>", "Provide token directly (skips prompt)")
+    .option("--email <email>", "Email for non-interactive login (requires SUPABASE_URL + SUPABASE_ANON_KEY)")
+    .option("--password <password>", "Password for non-interactive login (requires SUPABASE_URL + SUPABASE_ANON_KEY)")
+    .option("--no-git-setup", "Do not configure git credential helper")
     .option("--no-store", "Do not save token to ~/.instafy/config.json")
     .option("--json", "Output JSON")
     .action(async (opts) => {
@@ -48,7 +54,11 @@ program
             controllerUrl: opts.serverUrl,
             studioUrl: opts.studioUrl,
             token: opts.token,
+            email: opts.email,
+            password: opts.password,
+            gitSetup: opts.gitSetup,
             noStore: opts.store === false,
+            profile: opts.profile,
             json: opts.json,
         });
     }
@@ -60,10 +70,94 @@ program
 program
     .command("logout")
     .description("Clear the saved CLI access token")
+    .option("--profile <name>", "Clear the token for a named profile")
     .option("--json", "Output JSON")
     .action(async (opts) => {
     try {
-        await logout({ json: opts.json });
+        await logout({ json: opts.json, profile: opts.profile });
+    }
+    catch (error) {
+        console.error(kleur.red(String(error)));
+        process.exit(1);
+    }
+});
+const projectCommand = program
+    .command("project")
+    .description("Create/link and manage Instafy projects");
+projectCommand.action(() => projectCommand.outputHelp());
+const projectInitCommand = projectCommand
+    .command("init")
+    .description("Create an Instafy project and link this folder (.instafy/project.json)")
+    .option("--path <dir>", "Directory where the manifest should be written (default: cwd)");
+addServerUrlOptions(projectInitCommand);
+projectInitCommand
+    .option("--access-token <token>", "Instafy or Supabase access token")
+    .option("--profile <name>", "CLI profile to use when running commands in this folder")
+    .option("--project-type <type>", "Project type (customer|sandbox)")
+    .option("--org-id <uuid>", "Optional organization id")
+    .option("--org-name <name>", "Optional organization name")
+    .option("--org-slug <slug>", "Optional organization slug")
+    .option("--owner-user-id <uuid>", "Explicit owner user id (defaults to caller)")
+    .option("--json", "Output JSON")
+    .action(async (opts) => {
+    try {
+        await projectInit({
+            path: opts.path,
+            controllerUrl: opts.serverUrl ?? opts.controllerUrl,
+            accessToken: opts.accessToken,
+            profile: opts.profile,
+            projectType: opts.projectType,
+            orgId: opts.orgId,
+            orgName: opts.orgName,
+            orgSlug: opts.orgSlug,
+            ownerUserId: opts.ownerUserId,
+            json: opts.json,
+        });
+    }
+    catch (error) {
+        console.error(kleur.red(String(error)));
+        process.exit(1);
+    }
+});
+projectCommand
+    .command("profile")
+    .description("Get/set the CLI profile for this folder (.instafy/project.json)")
+    .argument("[profile]", "Profile name to set (omit to print current)")
+    .option("--unset", "Clear the configured profile for this folder")
+    .option("--path <dir>", "Directory to search for the manifest (default: cwd)")
+    .option("--json", "Output JSON")
+    .action(async (profile, opts) => {
+    try {
+        projectProfile({
+            profile,
+            unset: opts.unset,
+            path: opts.path,
+            json: opts.json,
+        });
+    }
+    catch (error) {
+        console.error(kleur.red(String(error)));
+        process.exit(1);
+    }
+});
+const projectListCommand = projectCommand
+    .command("list")
+    .description("List projects for your account")
+    .option("--access-token <token>", "Instafy or Supabase access token");
+addServerUrlOptions(projectListCommand);
+projectListCommand
+    .option("--org-id <uuid>", "Filter by organization id")
+    .option("--org-slug <slug>", "Filter by organization slug")
+    .option("--json", "Output JSON")
+    .action(async (opts) => {
+    try {
+        await (await import("./project.js")).listProjects({
+            controllerUrl: opts.serverUrl ?? opts.controllerUrl,
+            accessToken: opts.accessToken,
+            orgId: opts.orgId,
+            orgSlug: opts.orgSlug,
+            json: opts.json,
+        });
     }
     catch (error) {
         console.error(kleur.red(String(error)));
@@ -71,6 +165,7 @@ program
     }
 });
 const configCommand = program.command("config").description("Get/set saved CLI configuration");
+configCommand.action(() => configCommand.outputHelp());
 configCommand
     .command("path")
     .description("Print the config file path")
@@ -140,8 +235,12 @@ configCommand
         process.exit(1);
     }
 });
-const runtimeStartCommand = program
-    .command("runtime:start")
+const runtimeCommand = program
+    .command("runtime")
+    .description("Start/stop the local Instafy runtime");
+runtimeCommand.action(() => runtimeCommand.outputHelp());
+const runtimeStartCommand = runtimeCommand
+    .command("start")
     .description("Start a local runtime for this project")
     .option("--project <id>", "Project UUID");
 addServerUrlOptions(runtimeStartCommand);
@@ -180,8 +279,8 @@ runtimeStartCommand
         process.exit(1);
     }
 });
-program
-    .command("runtime:status")
+runtimeCommand
+    .command("status")
     .description("Show runtime health")
     .option("--json", "Output status as JSON")
     .action(async (opts) => {
@@ -193,8 +292,8 @@ program
         process.exit(1);
     }
 });
-program
-    .command("runtime:stop")
+runtimeCommand
+    .command("stop")
     .description("Stop the local Instafy runtime")
     .option("--json", "Output result as JSON")
     .action(async (opts) => {
@@ -206,8 +305,8 @@ program
         process.exit(1);
     }
 });
-const runtimeTokenCommand = program
-    .command("runtime:token")
+const runtimeTokenCommand = runtimeCommand
+    .command("token")
     .description("Mint a runtime access token")
     .option("--project <id>", "Project UUID (defaults to .instafy/project.json)");
 addServerUrlOptions(runtimeTokenCommand);
@@ -222,7 +321,7 @@ runtimeTokenCommand
             ? opts.project.trim()
             : findProjectManifest(process.cwd()).manifest?.projectId ?? null;
         if (!project) {
-            throw new Error("No project configured. Run `instafy project:init` or pass --project.");
+            throw new Error("No project configured. Run `instafy project init` or pass --project.");
         }
         await runtimeToken({
             project,
@@ -238,101 +337,140 @@ runtimeTokenCommand
         process.exit(1);
     }
 });
-const gitTokenCommand = program
-    .command("git:token")
-    .description("Mint a git access token for the project repo")
-    .option("--project <id>", "Project UUID (defaults to .instafy/project.json)");
-addServerUrlOptions(gitTokenCommand);
-addAccessTokenOptions(gitTokenCommand, "Instafy access token (required)");
-gitTokenCommand
-    .option("--supabase-access-token <token>", "Supabase session token (alternative to Studio token)")
-    .option("--supabase-access-token-file <path>", "File containing the Supabase session token")
-    .option("--scope <scope...>", "Requested scopes (git.read, git.write)")
-    .option("--ttl-seconds <seconds>", "Token TTL in seconds (default server policy)")
-    .option("--json", "Output token response as JSON")
+program
+    .command("git")
+    .description("Run git against the Instafy canonical checkout (.instafy/.git)")
+    .allowUnknownOption(true);
+const tunnelCommand = program
+    .command("tunnel")
+    .description("Create and manage shareable tunnels");
+tunnelCommand.action(() => tunnelCommand.outputHelp());
+const tunnelStartCommand = tunnelCommand
+    .command("start")
+    .description("Create a shareable tunnel URL for a local port (defaults to detached)")
+    .option("--port <port>", "Local port to expose (default 3000)")
+    .option("--project <id>", "Project UUID (defaults to .instafy/project.json or PROJECT_ID)");
+addServerUrlOptions(tunnelStartCommand);
+addAccessTokenOptions(tunnelStartCommand, "Instafy access token (defaults to saved `instafy login` token)");
+addServiceTokenOptions(tunnelStartCommand, "Instafy service token (advanced)");
+tunnelStartCommand
+    .option("--no-detach", "Run in foreground until interrupted")
+    .option("--rathole-bin <path>", "Path to rathole binary (or set RATHOLE_BIN)")
+    .option("--log-file <path>", "Write tunnel logs to a file (default: ~/.instafy/cli-tunnel-logs/*)")
+    .option("--json", "Output JSON")
     .action(async (opts) => {
     try {
-        const project = typeof opts.project === "string" && opts.project.trim()
-            ? opts.project.trim()
-            : findProjectManifest(process.cwd()).manifest?.projectId ?? null;
-        if (!project) {
-            throw new Error("No project configured. Run `instafy project:init` or pass --project.");
-        }
-        const ttlSecondsRaw = typeof opts.ttlSeconds === "string" ? opts.ttlSeconds.trim() : "";
-        const ttlSeconds = ttlSecondsRaw.length > 0 ? Number.parseInt(ttlSecondsRaw, 10) : undefined;
-        if (ttlSecondsRaw.length > 0 && (!Number.isFinite(ttlSeconds) || ttlSeconds <= 0)) {
-            throw new Error("--ttl-seconds must be a positive integer");
+        const port = opts.port ? Number(opts.port) : undefined;
+        const controllerToken = opts.serviceToken ??
+            opts.controllerToken ??
+            opts.accessToken ??
+            opts.controllerAccessToken;
+        if (opts.detach === false) {
+            await runTunnelCommand({
+                project: opts.project,
+                controllerUrl: opts.serverUrl ?? opts.controllerUrl,
+                controllerToken,
+                port,
+                ratholeBin: opts.ratholeBin,
+            });
+            return;
         }
-        await gitToken({
-            project,
+        const started = await startTunnelDetached({
+            project: opts.project,
             controllerUrl: opts.serverUrl ?? opts.controllerUrl,
-            controllerAccessToken: opts.accessToken ?? opts.controllerAccessToken,
-            supabaseAccessToken: opts.supabaseAccessToken,
-            supabaseAccessTokenFile: opts.supabaseAccessTokenFile,
-            scopes: opts.scope,
-            ttlSeconds,
-            json: opts.json,
+            controllerToken,
+            port,
+            ratholeBin: opts.ratholeBin,
+            logFile: opts.logFile,
         });
+        if (opts.json) {
+            console.log(JSON.stringify(started, null, 2));
+            return;
+        }
+        console.log(kleur.green(`Tunnel started: ${started.url} (tunnelId=${started.tunnelId})`));
+        console.log(kleur.gray(`pid=${started.pid} · port=${started.localPort}`));
+        console.log(kleur.gray(`log: ${started.logFile}`));
+        console.log("");
+        console.log("Next:");
+        console.log(`- ${kleur.cyan(`instafy tunnel list`)}`);
+        console.log(`- ${kleur.cyan(`instafy tunnel logs ${started.tunnelId} --follow`)}`);
+        console.log(`- ${kleur.cyan(`instafy tunnel stop ${started.tunnelId}`)}`);
+        if (process.platform !== "win32") {
+            console.log(kleur.gray(`(or) tail -n 200 -f ${started.logFile}`));
+        }
     }
     catch (error) {
         console.error(kleur.red(String(error)));
         process.exit(1);
     }
 });
-const projectInitCommand = program
-    .command("project:init")
-    .description("Create an Instafy project and link this folder (.instafy/project.json)")
-    .option("--path <dir>", "Directory where the manifest should be written (default: cwd)");
-addServerUrlOptions(projectInitCommand);
-projectInitCommand
-    .option("--access-token <token>", "Instafy or Supabase access token")
-    .option("--project-type <type>", "Project type (customer|sandbox)")
-    .option("--org-id <uuid>", "Optional organization id")
-    .option("--org-name <name>", "Optional organization name")
-    .option("--org-slug <slug>", "Optional organization slug")
-    .option("--owner-user-id <uuid>", "Explicit owner user id (defaults to caller)")
+tunnelCommand
+    .command("list")
+    .description("List local tunnel sessions started by this CLI")
+    .option("--all", "Include stopped/stale tunnels")
     .option("--json", "Output JSON")
     .action(async (opts) => {
     try {
-        await projectInit({
-            path: opts.path,
-            controllerUrl: opts.serverUrl ?? opts.controllerUrl,
-            accessToken: opts.accessToken,
-            projectType: opts.projectType,
-            orgId: opts.orgId,
-            orgName: opts.orgName,
-            orgSlug: opts.orgSlug,
-            ownerUserId: opts.ownerUserId,
+        const tunnels = listTunnelSessions({ all: Boolean(opts.all), json: Boolean(opts.json) });
+        if (opts.json) {
+            console.log(JSON.stringify(tunnels, null, 2));
+            return;
+        }
+        if (tunnels.length === 0) {
+            console.log(kleur.yellow("No tunnels found."));
+            return;
+        }
+        for (const tunnel of tunnels) {
+            console.log(`${tunnel.tunnelId} · ${tunnel.url} · port=${tunnel.localPort} · pid=${tunnel.pid}`);
+        }
+    }
+    catch (error) {
+        console.error(kleur.red(String(error)));
+        process.exit(1);
+    }
+});
+tunnelCommand
+    .command("stop")
+    .description("Stop a local tunnel session and revoke it")
+    .argument("[tunnelId]", "Tunnel ID (defaults to the only active tunnel)")
+    .option("--server-url <url>", "Instafy server URL")
+    .option("--access-token <token>", "Instafy access token (defaults to saved `instafy login` token)")
+    .option("--service-token <token>", "Instafy service token (advanced)")
+    .option("--json", "Output JSON")
+    .action(async (tunnelId, opts) => {
+    try {
+        const result = await stopTunnelSession({
+            tunnelId,
+            controllerUrl: opts.serverUrl,
+            controllerToken: opts.serviceToken ?? opts.accessToken,
             json: opts.json,
         });
+        if (opts.json) {
+            console.log(JSON.stringify(result, null, 2));
+            return;
+        }
+        console.log(kleur.green(`Tunnel stopped: ${result.tunnelId}`));
     }
     catch (error) {
         console.error(kleur.red(String(error)));
         process.exit(1);
     }
 });
-const tunnelCommand = program
-    .command("tunnel")
-    .description("Create a shareable tunnel URL for a local port")
-    .option("--port <port>", "Local port to expose (default 3000)")
-    .option("--project <id>", "Project UUID (defaults to .instafy/project.json or PROJECT_ID)");
-addServerUrlOptions(tunnelCommand);
-addAccessTokenOptions(tunnelCommand, "Instafy access token (defaults to saved `instafy login` token)");
-addServiceTokenOptions(tunnelCommand, "Instafy service token (advanced)");
 tunnelCommand
-    .option("--rathole-bin <path>", "Path to rathole binary (or set RATHOLE_BIN)")
-    .action(async (opts) => {
+    .command("logs")
+    .description("Show logs for a local tunnel session")
+    .argument("[tunnelId]", "Tunnel ID (defaults to the only active tunnel)")
+    .option("--lines <n>", "Number of lines to show", "200")
+    .option("--follow", "Follow log output (like tail -f)")
+    .option("--json", "Output JSON")
+    .action(async (tunnelId, opts) => {
     try {
-        const port = opts.port ? Number(opts.port) : undefined;
-        await runTunnelCommand({
-            project: opts.project,
-            controllerUrl: opts.serverUrl ?? opts.controllerUrl,
-            controllerToken: opts.serviceToken ??
-                opts.controllerToken ??
-                opts.accessToken ??
-                opts.controllerAccessToken,
-            port,
-            ratholeBin: opts.ratholeBin,
+        const lines = typeof opts.lines === "string" ? Number(opts.lines) : undefined;
+        await tailTunnelLogs({
+            tunnelId,
+            lines,
+            follow: Boolean(opts.follow),
+            json: Boolean(opts.json),
         });
     }
     catch (error) {
@@ -340,8 +478,12 @@ tunnelCommand
         process.exit(1);
     }
 });
-const orgListCommand = program
-    .command("org:list")
+const orgCommand = program
+    .command("org")
+    .description("Organization utilities");
+orgCommand.action(() => orgCommand.outputHelp());
+const orgListCommand = orgCommand
+    .command("list")
     .description("List organizations for your account");
 addServerUrlOptions(orgListCommand);
 orgListCommand
@@ -360,24 +502,42 @@ orgListCommand
         process.exit(1);
     }
 });
-const projectListCommand = program
-    .command("project:list")
-    .description("List projects for your account")
-    .option("--access-token <token>", "Instafy or Supabase access token");
-addServerUrlOptions(projectListCommand);
-projectListCommand
-    .option("--org-id <uuid>", "Filter by organization id")
-    .option("--org-slug <slug>", "Filter by organization slug")
+const profileCommand = program
+    .command("profile")
+    .description("Manage saved CLI profiles (~/.instafy/profiles)");
+profileCommand.action(() => profileCommand.outputHelp());
+profileCommand
+    .command("list")
+    .description("List saved CLI profiles")
     .option("--json", "Output JSON")
     .action(async (opts) => {
     try {
-        await (await import("./project.js")).listProjects({
-            controllerUrl: opts.serverUrl ?? opts.controllerUrl,
-            accessToken: opts.accessToken,
-            orgId: opts.orgId,
-            orgSlug: opts.orgSlug,
-            json: opts.json,
+        const names = listInstafyProfileNames();
+        const profiles = names.map((name) => {
+            const config = readInstafyProfileConfig(name);
+            return {
+                name,
+                path: getInstafyProfileConfigPath(name),
+                controllerUrl: config.controllerUrl ?? null,
+                studioUrl: config.studioUrl ?? null,
+                accessTokenSet: Boolean(config.accessToken),
+                updatedAt: config.updatedAt ?? null,
+            };
         });
+        if (opts.json) {
+            console.log(JSON.stringify({ profiles }, null, 2));
+            return;
+        }
+        if (profiles.length === 0) {
+            console.log(kleur.yellow("No profiles found."));
+            console.log(`Create one with: ${kleur.cyan("instafy login --profile <name>")}`);
+            return;
+        }
+        console.log(kleur.green("Instafy CLI profiles"));
+        for (const profile of profiles) {
+            const token = profile.accessTokenSet ? kleur.green("token") : kleur.yellow("no-token");
+            console.log(`- ${kleur.cyan(profile.name)} (${token})`);
+        }
     }
     catch (error) {
         console.error(kleur.red(String(error)));
@@ -415,23 +575,27 @@ function configureApiCommand(command, method) {
         }
     });
 }
-const apiGetCommand = program
-    .command("api:get")
+const apiCommand = program
+    .command("api", { hidden: true })
+    .description("Advanced: authenticated requests to the controller API");
+apiCommand.action(() => apiCommand.outputHelp());
+const apiGetCommand = apiCommand
+    .command("get")
     .description("Advanced: authenticated GET request to the controller API")
     .argument("<path>", "API path (or full URL), e.g. /conversations/<id>/messages?limit=50");
 configureApiCommand(apiGetCommand, "GET");
-const apiPostCommand = program
-    .command("api:post")
+const apiPostCommand = apiCommand
+    .command("post")
     .description("Advanced: authenticated POST request to the controller API")
     .argument("<path>", "API path (or full URL)");
 configureApiCommand(apiPostCommand, "POST");
-const apiPatchCommand = program
-    .command("api:patch")
+const apiPatchCommand = apiCommand
+    .command("patch")
     .description("Advanced: authenticated PATCH request to the controller API")
     .argument("<path>", "API path (or full URL)");
 configureApiCommand(apiPatchCommand, "PATCH");
-const apiDeleteCommand = program
-    .command("api:delete")
+const apiDeleteCommand = apiCommand
+    .command("delete")
     .description("Advanced: authenticated DELETE request to the controller API")
     .argument("<path>", "API path (or full URL)");
 configureApiCommand(apiDeleteCommand, "DELETE");
@@ -440,6 +604,27 @@ export async function runCli(argv = process.argv) {
         program.outputHelp();
         return;
     }
+    const args = argv.slice(2);
+    if (args[0] === "git") {
+        if (args[1] === "credential") {
+            try {
+                await runGitCredentialHelper(args[2] ?? "");
+            }
+            catch (error) {
+                console.error(String(error));
+                process.exitCode = 1;
+            }
+            return;
+        }
+        if (args[1] === "sync") {
+            const code = await runInstafyGitSync(args.slice(2));
+            process.exitCode = code;
+            return;
+        }
+        const code = runInstafyGit(args.slice(1));
+        process.exitCode = code;
+        return;
+    }
     await program.parseAsync(argv);
 }
 if (import.meta.url === pathToFileURL(process.argv[1] ?? "").href) {

package/dist/org.js

@@ -1,19 +1,24 @@
 import kleur from "kleur";
 import { resolveControllerUrl, resolveUserAccessToken } from "./config.js";
-function formatAuthRequiredError() {
-    return new Error("Login required. Run `instafy login` (recommended) or pass --access-token / set SUPABASE_ACCESS_TOKEN.");
-}
+import { formatAuthRejectedError, formatAuthRequiredError } from "./errors.js";
 export async function listOrganizations(params) {
     const controllerUrl = resolveControllerUrl({ controllerUrl: params.controllerUrl ?? null });
     const token = resolveUserAccessToken({ accessToken: params.accessToken ?? null });
     if (!token) {
-        throw formatAuthRequiredError();
+        throw formatAuthRequiredError({ retryCommand: "instafy org list" });
     }
     const response = await fetch(`${controllerUrl}/orgs`, {
         headers: { authorization: `Bearer ${token}` },
     });
     if (!response.ok) {
         const text = await response.text().catch(() => "");
+        if (response.status === 401 || response.status === 403) {
+            throw formatAuthRejectedError({
+                status: response.status,
+                responseBody: text,
+                retryCommand: "instafy org list",
+            });
+        }
         throw new Error(`Organization list failed (${response.status} ${response.statusText}): ${text}`);
     }
     const body = (await response.json());

package/dist/project-manifest.js

@@ -0,0 +1,24 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+export function findProjectManifest(startDir) {
+    let current = path.resolve(startDir);
+    const root = path.parse(current).root;
+    while (true) {
+        const candidate = path.join(current, ".instafy", "project.json");
+        if (existsSync(candidate)) {
+            try {
+                const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+                if (parsed?.projectId) {
+                    return { manifest: parsed, path: candidate };
+                }
+            }
+            catch {
+                // ignore malformed manifest
+            }
+        }
+        if (current === root)
+            break;
+        current = path.dirname(current);
+    }
+    return { manifest: null, path: null };
+}