@instafy/cli 0.1.8-staging.357 → 0.1.8-staging.365

package/README.md

@@ -9,6 +9,7 @@ Run Instafy projects locally and connect them back to Instafy Studio — from an
 0. Log in once: `instafy login`
    - Opens a Studio URL; the CLI continues automatically after you sign in.
    - Also enables Git auth (credential helper) for Instafy Git Service. Disable with `instafy login --no-git-setup`.
+   - Multiple accounts: `instafy login --profile work` (then bind folders with `instafy project:init --profile work` or `instafy project:profile work`).
    - Optional: set defaults with `instafy config set controller-url <url>` / `instafy config set studio-url <url>`
 1. Link a folder to a project:
    - VS Code: install the Instafy extension and run `Instafy: Link Workspace to Project`, or

package/dist/auth.js

@@ -4,7 +4,7 @@ import * as http from "node:http";
 import { createRequire } from "node:module";
 import { createInterface } from "node:readline/promises";
 import { stdin as input, stdout as output } from "node:process";
-import { clearInstafyCliConfig, getInstafyConfigPath, resolveConfiguredControllerUrl, resolveConfiguredStudioUrl, resolveUserAccessToken, writeInstafyCliConfig, } from "./config.js";
+import { clearInstafyCliConfig, clearInstafyProfileConfig, getInstafyConfigPath, getInstafyProfileConfigPath, resolveConfiguredControllerUrl, resolveConfiguredStudioUrl, resolveUserAccessToken, writeInstafyCliConfig, writeInstafyProfileConfig, } from "./config.js";
 import { installGitCredentialHelper, uninstallGitCredentialHelper } from "./git-setup.js";
 const require = createRequire(import.meta.url);
 const cliVersion = (() => {
@@ -45,11 +45,33 @@ function looksLikeLocalControllerUrl(controllerUrl) {
         return controllerUrl.includes("127.0.0.1") || controllerUrl.includes("localhost");
     }
 }
-function deriveDefaultStudioUrl(controllerUrl) {
-    if (looksLikeLocalControllerUrl(controllerUrl)) {
-        return "http://localhost:5173";
+async function isStudioHealthy(studioUrl, timeoutMs) {
+    const target = new URL("/cli/login", studioUrl).toString();
+    const abort = new AbortController();
+    const timeout = setTimeout(() => abort.abort(), timeoutMs);
+    timeout.unref?.();
+    try {
+        const response = await fetch(target, { signal: abort.signal });
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function resolveDefaultStudioUrl(controllerUrl) {
+    const hosted = "https://staging.instafy.dev";
+    if (isStagingCli) {
+        return hosted;
     }
-    return "https://staging.instafy.dev";
+    if (!looksLikeLocalControllerUrl(controllerUrl)) {
+        return hosted;
+    }
+    const local = "http://localhost:5173";
+    const healthy = await isStudioHealthy(local, 250);
+    return healthy ? local : hosted;
 }
 async function isControllerHealthy(controllerUrl, timeoutMs) {
     const target = `${controllerUrl.replace(/\/$/, "")}/healthz`;
@@ -212,10 +234,11 @@ async function startCliLoginCallbackServer() {
     };
 }
 export async function login(options) {
+    const profile = typeof options.profile === "string" && options.profile.trim() ? options.profile.trim() : null;
     const explicitControllerUrl = normalizeUrl(options.controllerUrl ?? null) ??
         normalizeUrl(process.env["INSTAFY_SERVER_URL"] ?? null) ??
         normalizeUrl(process.env["CONTROLLER_BASE_URL"] ?? null) ??
-        (isStagingCli ? null : resolveConfiguredControllerUrl());
+        (isStagingCli ? null : resolveConfiguredControllerUrl({ profile }));
     const defaultLocalControllerUrl = "http://127.0.0.1:8788";
     const defaultHostedControllerUrl = "https://controller.instafy.dev";
     const controllerUrl = explicitControllerUrl ??
@@ -226,12 +249,16 @@ export async function login(options) {
                 : defaultHostedControllerUrl);
     const studioUrl = normalizeUrl(options.studioUrl ?? null) ??
         normalizeUrl(process.env["INSTAFY_STUDIO_URL"] ?? null) ??
-        (isStagingCli ? null : resolveConfiguredStudioUrl()) ??
-        deriveDefaultStudioUrl(controllerUrl);
+        (isStagingCli ? null : resolveConfiguredStudioUrl({ profile })) ??
+        (await resolveDefaultStudioUrl(controllerUrl));
     const url = new URL("/cli/login", studioUrl);
     url.searchParams.set("serverUrl", controllerUrl);
     if (options.json) {
-        console.log(JSON.stringify({ url: url.toString(), configPath: getInstafyConfigPath() }));
+        console.log(JSON.stringify({
+            url: url.toString(),
+            profile,
+            configPath: profile ? getInstafyProfileConfigPath(profile) : getInstafyConfigPath(),
+        }));
         return;
     }
     let callbackServer = null;
@@ -259,7 +286,7 @@ export async function login(options) {
         console.log("2) After you sign in, copy the token shown on that page.");
     }
     console.log("");
-    const existing = resolveUserAccessToken();
+    const existing = resolveUserAccessToken({ profile });
     let token = provided;
     if (!token && callbackServer) {
         if (input.isTTY) {
@@ -337,9 +364,14 @@ export async function login(options) {
         throw new Error("No token provided.");
     }
     if (!options.noStore) {
-        writeInstafyCliConfig({ controllerUrl, studioUrl, accessToken: token });
+        if (profile) {
+            writeInstafyProfileConfig(profile, { controllerUrl, studioUrl, accessToken: token });
+        }
+        else {
+            writeInstafyCliConfig({ controllerUrl, studioUrl, accessToken: token });
+        }
         console.log("");
-        console.log(kleur.green(`Saved token to ${getInstafyConfigPath()}`));
+        console.log(kleur.green(`Saved token to ${profile ? getInstafyProfileConfigPath(profile) : getInstafyConfigPath()}`));
         if (options.gitSetup !== false) {
             try {
                 const result = installGitCredentialHelper();
@@ -362,16 +394,26 @@ export async function login(options) {
     console.log(`- ${kleur.cyan("instafy runtime:start")}`);
 }
 export async function logout(options) {
-    clearInstafyCliConfig(["accessToken"]);
-    try {
-        uninstallGitCredentialHelper();
+    if (options?.profile) {
+        clearInstafyProfileConfig(options.profile, ["accessToken"]);
     }
-    catch {
-        // ignore git helper cleanup failures
+    else {
+        clearInstafyCliConfig(["accessToken"]);
+        try {
+            uninstallGitCredentialHelper();
+        }
+        catch {
+            // ignore git helper cleanup failures
+        }
     }
     if (options?.json) {
         console.log(JSON.stringify({ ok: true }));
         return;
     }
-    console.log(kleur.green("Logged out (cleared saved access token)."));
+    if (options?.profile) {
+        console.log(kleur.green(`Logged out (cleared saved access token for profile "${options.profile}").`));
+    }
+    else {
+        console.log(kleur.green("Logged out (cleared saved access token)."));
+    }
 }

package/dist/config.js

@@ -1,8 +1,10 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { findProjectManifest } from "./project-manifest.js";
 const INSTAFY_DIR = path.join(os.homedir(), ".instafy");
 const CONFIG_PATH = path.join(INSTAFY_DIR, "config.json");
+const PROFILES_DIR = path.join(INSTAFY_DIR, "profiles");
 function normalizeToken(value) {
     if (typeof value !== "string") {
         return null;
@@ -24,9 +26,45 @@ function normalizeUrl(value) {
     }
     return trimmed.replace(/\/$/, "");
 }
+function normalizeProfileName(value) {
+    const trimmed = typeof value === "string" ? value.trim() : "";
+    if (!trimmed) {
+        return null;
+    }
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(trimmed)) {
+        throw new Error(`Invalid profile name "${value}". Use letters/numbers plus . _ - (max 64 chars).`);
+    }
+    if (trimmed.includes("..")) {
+        throw new Error(`Invalid profile name "${value}".`);
+    }
+    return trimmed;
+}
 export function getInstafyConfigPath() {
     return CONFIG_PATH;
 }
+export function getInstafyProfilesDirPath() {
+    return PROFILES_DIR;
+}
+export function getInstafyProfileConfigPath(profile) {
+    const normalized = normalizeProfileName(profile);
+    if (!normalized) {
+        throw new Error("Profile name is required.");
+    }
+    return path.join(PROFILES_DIR, `${normalized}.json`);
+}
+export function listInstafyProfileNames() {
+    try {
+        const entries = fs.readdirSync(PROFILES_DIR, { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => entry.name.slice(0, -".json".length))
+            .filter(Boolean)
+            .sort((a, b) => a.localeCompare(b));
+    }
+    catch {
+        return [];
+    }
+}
 export function readInstafyCliConfig() {
     try {
         const raw = fs.readFileSync(CONFIG_PATH, "utf8");
@@ -46,6 +84,26 @@ export function readInstafyCliConfig() {
         return {};
     }
 }
+export function readInstafyProfileConfig(profile) {
+    const filePath = getInstafyProfileConfigPath(profile);
+    try {
+        const raw = fs.readFileSync(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object") {
+            return {};
+        }
+        const record = parsed;
+        return {
+            controllerUrl: normalizeUrl(typeof record.controllerUrl === "string" ? record.controllerUrl : null),
+            studioUrl: normalizeUrl(typeof record.studioUrl === "string" ? record.studioUrl : null),
+            accessToken: normalizeToken(typeof record.accessToken === "string" ? record.accessToken : null),
+            updatedAt: typeof record.updatedAt === "string" ? record.updatedAt : null,
+        };
+    }
+    catch {
+        return {};
+    }
+}
 export function writeInstafyCliConfig(update) {
     const existing = readInstafyCliConfig();
     const next = {
@@ -64,6 +122,25 @@ export function writeInstafyCliConfig(update) {
     }
     return next;
 }
+export function writeInstafyProfileConfig(profile, update) {
+    const filePath = getInstafyProfileConfigPath(profile);
+    const existing = readInstafyProfileConfig(profile);
+    const next = {
+        controllerUrl: normalizeUrl(update.controllerUrl ?? existing.controllerUrl ?? null),
+        studioUrl: normalizeUrl(update.studioUrl ?? existing.studioUrl ?? null),
+        accessToken: normalizeToken(update.accessToken ?? existing.accessToken ?? null),
+        updatedAt: new Date().toISOString(),
+    };
+    fs.mkdirSync(PROFILES_DIR, { recursive: true });
+    fs.writeFileSync(filePath, JSON.stringify(next, null, 2), { encoding: "utf8" });
+    try {
+        fs.chmodSync(filePath, 0o600);
+    }
+    catch {
+        // ignore chmod failures (windows / unusual fs)
+    }
+    return next;
+}
 export function clearInstafyCliConfig(keys) {
     if (!keys || keys.length === 0) {
         try {
@@ -81,20 +158,70 @@ export function clearInstafyCliConfig(keys) {
     }
     writeInstafyCliConfig(next);
 }
-export function resolveConfiguredControllerUrl() {
+export function clearInstafyProfileConfig(profile, keys) {
+    const filePath = getInstafyProfileConfigPath(profile);
+    if (!keys || keys.length === 0) {
+        try {
+            fs.rmSync(filePath, { force: true });
+        }
+        catch {
+            // ignore
+        }
+        return;
+    }
+    const existing = readInstafyProfileConfig(profile);
+    const next = { ...existing };
+    for (const key of keys) {
+        next[key] = null;
+    }
+    writeInstafyProfileConfig(profile, next);
+}
+export function resolveActiveProfileName(params) {
+    const explicit = normalizeProfileName(params?.profile ?? null);
+    if (explicit) {
+        return explicit;
+    }
+    const fromEnv = normalizeProfileName(process.env["INSTAFY_PROFILE"] ?? null);
+    if (fromEnv) {
+        return fromEnv;
+    }
+    const cwd = (params?.cwd ?? process.cwd()).trim();
+    if (!cwd) {
+        return null;
+    }
+    const manifest = findProjectManifest(cwd).manifest;
+    return normalizeProfileName(manifest?.profile ?? null);
+}
+export function resolveConfiguredControllerUrl(params) {
+    const profile = resolveActiveProfileName(params);
+    if (profile) {
+        const configured = readInstafyProfileConfig(profile);
+        return normalizeUrl(configured.controllerUrl ?? null);
+    }
     const config = readInstafyCliConfig();
     return normalizeUrl(config.controllerUrl ?? null);
 }
-export function resolveConfiguredStudioUrl() {
+export function resolveConfiguredStudioUrl(params) {
+    const profile = resolveActiveProfileName(params);
+    if (profile) {
+        const configured = readInstafyProfileConfig(profile);
+        return normalizeUrl(configured.studioUrl ?? null);
+    }
     const config = readInstafyCliConfig();
     return normalizeUrl(config.studioUrl ?? null);
 }
-export function resolveConfiguredAccessToken() {
+export function resolveConfiguredAccessToken(params) {
+    const profile = resolveActiveProfileName(params);
+    if (profile) {
+        const configured = readInstafyProfileConfig(profile);
+        return normalizeToken(configured.accessToken ?? null);
+    }
     const config = readInstafyCliConfig();
     return normalizeToken(config.accessToken ?? null);
 }
 export function resolveControllerUrl(params) {
-    const config = readInstafyCliConfig();
+    const profile = resolveActiveProfileName({ profile: params?.profile ?? null, cwd: params?.cwd ?? null });
+    const config = profile ? readInstafyProfileConfig(profile) : readInstafyCliConfig();
     return (normalizeUrl(params?.controllerUrl ?? null) ??
         normalizeUrl(process.env["INSTAFY_SERVER_URL"] ?? null) ??
         normalizeUrl(process.env["CONTROLLER_BASE_URL"] ?? null) ??
@@ -102,7 +229,8 @@ export function resolveControllerUrl(params) {
         "http://127.0.0.1:8788");
 }
 export function resolveUserAccessToken(params) {
-    const config = readInstafyCliConfig();
+    const profile = resolveActiveProfileName({ profile: params?.profile ?? null, cwd: params?.cwd ?? null });
+    const config = profile ? readInstafyProfileConfig(profile) : readInstafyCliConfig();
     return (normalizeToken(params?.accessToken ?? null) ??
         normalizeToken(process.env["INSTAFY_ACCESS_TOKEN"] ?? null) ??
         normalizeToken(process.env["CONTROLLER_ACCESS_TOKEN"] ?? null) ??

package/dist/git.js

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import kleur from "kleur";
-import { resolveConfiguredAccessToken } from "./config.js";
+import { resolveConfiguredAccessToken, resolveControllerUrl } from "./config.js";
 function normalizeToken(value) {
     if (typeof value !== "string") {
         return null;
@@ -68,10 +68,7 @@ export async function mintGitAccessToken(params) {
     };
 }
 export async function gitToken(options) {
-    const controllerUrl = options.controllerUrl ??
-        process.env["INSTAFY_SERVER_URL"] ??
-        process.env["CONTROLLER_BASE_URL"] ??
-        "http://127.0.0.1:8788";
+    const controllerUrl = resolveControllerUrl({ controllerUrl: options.controllerUrl ?? null });
     const token = resolveControllerAccessToken({
         controllerAccessToken: options.controllerAccessToken,
         supabaseAccessToken: options.supabaseAccessToken,

package/dist/index.js

@@ -6,10 +6,11 @@ import { runtimeStart, runtimeStatus, runtimeStop, runtimeToken, findProjectMani
 import { login, logout } from "./auth.js";
 import { gitToken } from "./git.js";
 import { runGitCredentialHelper } from "./git-credential.js";
-import { projectInit } from "./project.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";
 export const program = new Command();
 const require = createRequire(import.meta.url);
 const pkg = require("../package.json");
@@ -40,6 +41,7 @@ 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("--no-git-setup", "Do not configure git credential helper")
     .option("--no-store", "Do not save token to ~/.instafy/config.json")
@@ -52,6 +54,7 @@ program
             token: opts.token,
             gitSetup: opts.gitSetup,
             noStore: opts.store === false,
+            profile: opts.profile,
             json: opts.json,
         });
     }
@@ -63,10 +66,11 @@ 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)));
@@ -80,6 +84,7 @@ const projectInitCommand = program
 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")
@@ -92,6 +97,7 @@ projectInitCommand
             path: opts.path,
             controllerUrl: opts.serverUrl ?? opts.controllerUrl,
             accessToken: opts.accessToken,
+            profile: opts.profile,
             projectType: opts.projectType,
             orgId: opts.orgId,
             orgName: opts.orgName,
@@ -105,6 +111,65 @@ projectInitCommand
         process.exit(1);
     }
 });
+program
+    .command("project: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);
+    }
+});
+program
+    .command("profile:list")
+    .description("List saved CLI profiles (~/.instafy/profiles)")
+    .option("--json", "Output JSON")
+    .action(async (opts) => {
+    try {
+        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)));
+        process.exit(1);
+    }
+});
 const configCommand = program.command("config").description("Get/set saved CLI configuration");
 configCommand
     .command("path")
@@ -274,8 +339,8 @@ runtimeTokenCommand
     }
 });
 const gitTokenCommand = program
-    .command("git:token")
-    .description("Mint a git access token for the project repo")
+    .command("git:token", { hidden: true })
+    .description("Advanced: 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)");
@@ -536,22 +601,22 @@ function configureApiCommand(command, method) {
     });
 }
 const apiGetCommand = program
-    .command("api:get")
+    .command("api:get", { hidden: true })
     .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")
+    .command("api:post", { hidden: true })
     .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")
+    .command("api:patch", { hidden: true })
     .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")
+    .command("api:delete", { hidden: true })
     .description("Advanced: authenticated DELETE request to the controller API")
     .argument("<path>", "API path (or full URL)");
 configureApiCommand(apiDeleteCommand, "DELETE");

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 };
+}

package/dist/project.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import kleur from "kleur";
-import { resolveControllerUrl, resolveUserAccessToken } from "./config.js";
+import { getInstafyProfileConfigPath, resolveControllerUrl, resolveUserAccessToken } from "./config.js";
 import { formatAuthRequiredError } from "./errors.js";
+import { findProjectManifest } from "./project-manifest.js";
 async function fetchOrganizations(controllerUrl, token) {
     const response = await fetch(`${controllerUrl}/orgs`, {
         headers: {
@@ -111,8 +112,16 @@ export async function listProjects(options) {
 }
 export async function projectInit(options) {
     const rootDir = path.resolve(options.path ?? process.cwd());
-    const controllerUrl = resolveControllerUrl({ controllerUrl: options.controllerUrl ?? null });
-    const token = resolveUserAccessToken({ accessToken: options.accessToken ?? null });
+    const controllerUrl = resolveControllerUrl({
+        controllerUrl: options.controllerUrl ?? null,
+        profile: options.profile ?? null,
+        cwd: rootDir,
+    });
+    const token = resolveUserAccessToken({
+        accessToken: options.accessToken ?? null,
+        profile: options.profile ?? null,
+        cwd: rootDir,
+    });
     if (!token) {
         throw formatAuthRequiredError({
             retryCommand: "instafy project:init",
@@ -146,6 +155,7 @@ export async function projectInit(options) {
             orgId: json.org_id ?? org.orgId ?? null,
             orgName: json.org_name ?? org.orgName ?? null,
             controllerUrl,
+            profile: options.profile ?? null,
             createdAt: new Date().toISOString(),
         }, null, 2), "utf8");
     }
@@ -171,3 +181,47 @@ export async function projectInit(options) {
     }
     return json;
 }
+export function projectProfile(options) {
+    const rootDir = path.resolve(options.path ?? process.cwd());
+    const manifestInfo = findProjectManifest(rootDir);
+    if (!manifestInfo.path || !manifestInfo.manifest) {
+        throw new Error("No project configured. Run `instafy project:init` in this folder first.");
+    }
+    const shouldUpdate = options.unset === true || typeof options.profile === "string";
+    const currentProfile = typeof manifestInfo.manifest.profile === "string" && manifestInfo.manifest.profile.trim()
+        ? manifestInfo.manifest.profile.trim()
+        : null;
+    if (!shouldUpdate) {
+        if (options.json) {
+            console.log(JSON.stringify({ ok: true, path: manifestInfo.path, profile: currentProfile }, null, 2));
+        }
+        else {
+            console.log(kleur.green("Project profile"));
+            console.log(`Manifest: ${manifestInfo.path}`);
+            console.log(`Profile: ${currentProfile ?? kleur.yellow("(none)")}`);
+        }
+        return { path: manifestInfo.path, profile: currentProfile };
+    }
+    const nextProfileRaw = options.unset === true ? null : typeof options.profile === "string" ? options.profile.trim() : null;
+    const nextProfile = nextProfileRaw && nextProfileRaw.length > 0 ? nextProfileRaw : null;
+    if (nextProfile) {
+        getInstafyProfileConfigPath(nextProfile);
+    }
+    const updated = { ...manifestInfo.manifest };
+    if (nextProfile) {
+        updated.profile = nextProfile;
+    }
+    else {
+        delete updated.profile;
+    }
+    fs.writeFileSync(manifestInfo.path, JSON.stringify(updated, null, 2), "utf8");
+    if (options.json) {
+        console.log(JSON.stringify({ ok: true, path: manifestInfo.path, profile: nextProfile }, null, 2));
+    }
+    else {
+        console.log(kleur.green("Updated project profile."));
+        console.log(`Manifest: ${manifestInfo.path}`);
+        console.log(`Profile: ${nextProfile ?? kleur.yellow("(none)")}`);
+    }
+    return { path: manifestInfo.path, profile: nextProfile };
+}

package/dist/runtime.js

@@ -7,6 +7,7 @@ import { randomUUID } from "node:crypto";
 import os from "node:os";
 import { ensureRatholeBinary } from "./rathole.js";
 import { resolveConfiguredAccessToken } from "./config.js";
+import { findProjectManifest } from "./project-manifest.js";
 const INSTAFY_DIR = path.join(os.homedir(), ".instafy");
 const STATE_FILE = path.join(INSTAFY_DIR, "cli-runtime-state.json");
 const LOG_DIR = path.join(INSTAFY_DIR, "cli-runtime-logs");
@@ -142,28 +143,7 @@ function normalizeToken(value) {
     const trimmed = value.trim();
     return trimmed.length > 0 ? trimmed : null;
 }
-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 };
-}
+export { findProjectManifest };
 function readTokenFromFile(filePath) {
     const normalized = normalizeToken(filePath);
     if (!normalized) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@instafy/cli",
-  "version": "0.1.8-staging.357",
+  "version": "0.1.8-staging.365",
   "description": "Run Instafy projects locally, link folders to Studio, and share previews/webhooks via tunnels.",
   "private": false,
   "publishConfig": {