@getxflow/cli 0.6.5 → 0.7.0

package/dist/api.js

@@ -98,26 +98,50 @@ async function send(client, path, options = {}) {
     assertProtocol(response);
     return response;
 }
-async function readError(response) {
+/**
+ * The body is not an answer of the API: every one of those is JSON with content.
+ * A page in its place, or nothing at all, means the request never reached a
+ * route, so we say that instead of quoting what came back.
+ *
+ * Markup never goes into the hint. The reader is an agent, and 200 characters of
+ * HTML read like a bug in its own code rather than like a platform that has not
+ * deployed this endpoint yet. An empty body is worse still: it used to leave no
+ * hint at all.
+ *
+ * Plain text is kept: some proxies say something useful in one line.
+ */
+function notAnAnswer(status, apiUrl, body) {
+    const text = body.trim();
+    if (text.length > 0 && !text.startsWith('<')) {
+        return new ApiError(`Request rejected (${status})`, 'unknown', status, text.slice(0, 200));
+    }
+    // 404 is a missing route, 405 a route without this method. Both mean the same
+    // thing to the caller: this platform does not serve the endpoint yet.
+    if (status === 404 || status === 405) {
+        return new ApiError(`The platform does not serve that endpoint (${status})`, 'not_deployed', status, `This CLI is ${version_1.CLI_VERSION} and ${apiUrl} is older than it. Wait for the platform to deploy, or check XFLOW_API_URL`);
+    }
+    return new ApiError(`The platform is not answering (${status})`, 'unavailable', status, `Something on the way to ${apiUrl} answered with a page instead of an answer. Retry in a minute`);
+}
+async function readError(response, client) {
     const text = await response.text().catch(() => '');
     try {
         const parsed = JSON.parse(text);
         return new ApiError(parsed.error || `Request rejected (${response.status})`, parsed.code || 'unknown', response.status, parsed.hint, parsed.issues, parsed.limit, parsed.removing);
     }
     catch {
-        return new ApiError(`Request rejected (${response.status})`, 'unknown', response.status, text.slice(0, 200) || undefined);
+        return notAnAnswer(response.status, client.apiUrl, text);
     }
 }
 async function apiJson(client, path, options = {}) {
     const response = await send(client, path, options);
     if (!response.ok)
-        throw await readError(response);
+        throw await readError(response, client);
     return (await response.json());
 }
 async function apiBinary(client, path) {
     const response = await send(client, path, { timeoutMs: TRANSFER_TIMEOUT_MS });
     if (!response.ok)
-        throw await readError(response);
+        throw await readError(response, client);
     return Buffer.from(await response.arrayBuffer());
 }
 async function apiUpload(client, path, body, headers = {}) {

package/dist/bin.js

@@ -4,6 +4,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const api_1 = require("./api");
 const args_1 = require("./args");
 const config_1 = require("./config");
+const credentials_1 = require("./credentials");
 const errors_1 = require("./errors");
 const help_1 = require("./help");
 const limits_1 = require("./limits");
@@ -19,6 +20,7 @@ const env_1 = require("./commands/env");
 const functions_1 = require("./commands/functions");
 const logs_1 = require("./commands/logs");
 const mcp_1 = require("./commands/mcp");
+const org_1 = require("./commands/org");
 const schedules_1 = require("./commands/schedules");
 const skills_1 = require("./commands/skills");
 const sources_1 = require("./commands/sources");
@@ -38,11 +40,21 @@ async function run(args) {
             await (0, auth_1.login)();
             return;
         case 'logout':
-            (0, auth_1.logout)();
+            (0, auth_1.logout)(rest);
             return;
         case 'whoami':
             await (0, auth_1.whoami)();
             return;
+        case 'org':
+            if (second === 'switch') {
+                (0, org_1.orgSwitch)({ ...args, words: args.words.slice(2) });
+                return;
+            }
+            if (second === undefined || second === 'list') {
+                (0, org_1.orgList)();
+                return;
+            }
+            throw new errors_1.CliError(`Unknown command: org ${second}`, 'Available: list and switch');
         case 'templates':
             await (0, projects_1.templates)();
             return;
@@ -107,11 +119,19 @@ async function run(args) {
             }
             throw new errors_1.CliError(`Unknown command: env ${second}`, 'Available: list, check, set and rm');
         case 'connections':
+            if (second === 'link') {
+                await (0, connections_1.connectionsLink)(rest);
+                return;
+            }
+            if (second === 'unlink') {
+                await (0, connections_1.connectionsUnlink)(rest);
+                return;
+            }
             if (second === undefined || second === 'list') {
                 await (0, connections_1.connectionsList)();
                 return;
             }
-            throw new errors_1.CliError(`Unknown command: connections ${second}`, 'Available: list');
+            throw new errors_1.CliError(`Unknown command: connections ${second}`, 'Available: list, link and unlink');
         case 'schedules':
             if (second === 'set') {
                 await (0, schedules_1.schedulesSet)(rest);
@@ -208,6 +228,9 @@ async function main() {
                 (0, ui_1.note)((0, ui_1.dim)(`  ${(0, limits_1.limitLine)(e.limit)}`));
             if (e.hint)
                 (0, ui_1.note)((0, ui_1.dim)(`  ${e.hint}`));
+            if (e.code === 'not_found' && (0, credentials_1.anyMultipleOrgs)()) {
+                (0, ui_1.note)((0, ui_1.dim)('  Several organizations are signed in: the answer may live in another one, see xflow org'));
+            }
             quiet = quiet || e.code === 'outdated_cli';
             return 1;
         }

package/dist/commands/auth.js

@@ -5,27 +5,17 @@ exports.logout = logout;
 exports.whoami = whoami;
 const node_os_1 = require("node:os");
 const api_1 = require("../api");
+const args_1 = require("../args");
 const config_1 = require("../config");
 const credentials_1 = require("../credentials");
 const errors_1 = require("../errors");
 const limits_1 = require("../limits");
 const session_1 = require("../session");
 const ui_1 = require("../ui");
-function localConfig() {
-    const root = (0, config_1.findProjectRoot)();
-    if (!root)
-        return undefined;
-    try {
-        return (0, config_1.readConfig)(root);
-    }
-    catch {
-        return undefined;
-    }
-}
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** Device flow: the key is issued after confirmation in the browser, never typed. */
 async function login() {
-    const config = localConfig();
+    const config = (0, config_1.localConfig)();
     const client = (0, session_1.anonymous)(config);
     // The machine name becomes the key label on the platform.
     const start = await (0, api_1.apiJson)(client, '/api/v1/auth/device', {
@@ -74,22 +64,55 @@ async function awaitConfirmation(client, start) {
         }
         if (poll.status === 'pending')
             continue;
-        (0, credentials_1.saveCredential)(client.apiUrl, {
-            token: poll.token,
-            organizationId: poll.organization_id,
-            projectId: poll.project_id,
-        });
-        (0, ui_1.ok)(`Signed in, the key is stored for ${client.apiUrl}`);
+        if (!poll.organization_id) {
+            throw new errors_1.CliError('The platform did not name the organization of the key', 'Try again: xflow login');
+        }
+        (0, credentials_1.saveOrgCredential)(client.apiUrl, poll.organization_id, poll.token);
+        // The key of every other stored organization stays; this one becomes active.
+        const authed = { apiUrl: client.apiUrl, token: poll.token };
+        const name = await (0, api_1.apiJson)(authed, '/api/v1/me')
+            .then((me) => me.organization.name)
+            .catch(() => null);
+        if (name)
+            (0, credentials_1.rememberOrgName)(client.apiUrl, poll.organization_id, name);
+        (0, ui_1.ok)(`Signed in to "${name ?? poll.organization_id}", the key is stored for ${client.apiUrl}`);
+        const others = (0, credentials_1.listOrgs)(client.apiUrl).length - 1;
+        if (others > 0)
+            (0, ui_1.note)((0, ui_1.dim)(`  ${others} more stored: xflow org`));
         return;
     }
 }
-function logout() {
-    const apiUrl = (0, config_1.apiUrlFor)(localConfig());
-    if ((0, credentials_1.forgetCredential)(apiUrl)) {
-        (0, ui_1.ok)(`The key for ${apiUrl} is deleted`);
+function logout(args) {
+    const apiUrl = (0, config_1.apiUrlFor)((0, config_1.localConfig)());
+    if ((0, args_1.flagBool)(args, 'all')) {
+        if ((0, credentials_1.forgetAllOrgs)(apiUrl))
+            (0, ui_1.ok)(`Every key for ${apiUrl} is deleted`);
+        else
+            (0, ui_1.warn)(`There is no stored key for ${apiUrl}`);
+        return;
     }
-    else {
-        (0, ui_1.warn)(`There is no stored key for ${apiUrl}`);
+    const orgs = (0, credentials_1.listOrgs)(apiUrl);
+    const active = orgs.find((org) => org.active);
+    if (!active) {
+        // A record from an older CLI names no organization: forget the whole address.
+        if ((0, credentials_1.forgetAllOrgs)(apiUrl))
+            (0, ui_1.ok)(`The key for ${apiUrl} is deleted`);
+        else
+            (0, ui_1.warn)(`There is no stored key for ${apiUrl}`);
+        return;
+    }
+    const { nextActive } = (0, credentials_1.forgetOrg)(apiUrl, active.organizationId);
+    (0, ui_1.ok)(`Signed out of "${active.name ?? active.organizationId}"`);
+    // Inside a folder bound to another organization the command may read as
+    // "revoke access to this project", which is not what just happened.
+    const root = (0, config_1.findProjectRoot)();
+    const boundId = root ? (0, config_1.readState)(root).organizationId : undefined;
+    if (boundId && boundId !== active.organizationId) {
+        const bound = orgs.find((org) => org.organizationId === boundId);
+        (0, ui_1.note)((0, ui_1.dim)(`  This folder is bound to "${bound?.name ?? boundId}": its key is untouched`));
+    }
+    if (nextActive) {
+        (0, ui_1.note)((0, ui_1.dim)(`  Active organization now: "${nextActive.name ?? nextActive.organizationId}". Every key: xflow logout --all`));
     }
 }
 /** Suffix for a non-active subscription. */
@@ -99,18 +122,23 @@ const SUBSCRIPTION_STATE = {
     terminated: ', the subscription is terminated',
 };
 async function whoami() {
-    const config = localConfig();
+    const config = (0, config_1.localConfig)();
     const client = (0, session_1.connect)(config);
     const me = await (0, api_1.apiJson)(client, '/api/v1/me');
     (0, ui_1.out)(`Organization: ${me.organization.name ?? me.organization.id}`);
     (0, ui_1.out)(`Key:          xfk_${me.key.prefix}… (${me.key.scopes.join(', ')})`);
     (0, ui_1.out)(`Platform:     ${client.apiUrl}`);
-    // Same condition as in connect: for an address out of xflow.json the env key is ignored.
-    if (process.env.XFLOW_TOKEN?.trim() && client.apiUrl === (0, config_1.apiUrlFor)()) {
-        (0, ui_1.note)((0, ui_1.dim)('  The key comes from XFLOW_TOKEN, the one stored in ~/.xflow is not used'));
+    (0, credentials_1.rememberOrgName)(client.apiUrl, me.organization.id, me.organization.name);
+    if (client.source === 'env') {
+        (0, ui_1.note)((0, ui_1.dim)('  The key comes from XFLOW_TOKEN, the ones stored in ~/.xflow are not used'));
+    }
+    else if (client.source === 'folder') {
+        (0, ui_1.note)((0, ui_1.dim)('  The key follows the organization this folder is bound to (.xflow/state.json)'));
     }
-    else if (!(0, credentials_1.readCredential)(client.apiUrl)) {
-        (0, ui_1.note)((0, ui_1.dim)('  The key is not stored'));
+    else {
+        const others = (0, credentials_1.listOrgs)(client.apiUrl).length - 1;
+        if (others > 0)
+            (0, ui_1.note)((0, ui_1.dim)(`  The key of the active organization, ${others} more stored: xflow org`));
     }
     if (me.billing) {
         const pkg = me.billing.package_title ? `, ${me.billing.package_title}` : '';

package/dist/commands/connections.js

@@ -1,10 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.connectionsList = connectionsList;
+exports.connectionsLink = connectionsLink;
+exports.connectionsUnlink = connectionsUnlink;
 const api_1 = require("../api");
+const args_1 = require("../args");
 const config_1 = require("../config");
+const errors_1 = require("../errors");
 const session_1 = require("../session");
 const ui_1 = require("../ui");
+const env_1 = require("./env");
 // An expiring token is renewed by any build, a revoked one is not renewed by
 // anything until a human reconnects the account. Telling them apart saves a
 // pointless rebuild, so every case gets its own line.
@@ -26,10 +31,35 @@ function state(row) {
             return 'linked';
     }
 }
+function endpoint(projectId) {
+    return `/api/v1/projects/${projectId}/connections`;
+}
+/**
+ * Which connection the argument means. Identifiers are what the platform knows,
+ * names are what the list shows and what a human said out loud; both are
+ * accepted, so nobody has to copy a UUID from somewhere the command never
+ * printed it. Names repeat across accounts of the same service, so an ambiguous
+ * one is refused with the identifiers rather than resolved by luck.
+ */
+function resolve(connections, target) {
+    const byId = connections.find((row) => row.id === target);
+    if (byId)
+        return byId;
+    const wanted = target.toLowerCase();
+    const named = connections.filter((row) => row.label.toLowerCase() === wanted);
+    if (named.length === 1)
+        return named[0];
+    if (named.length > 1) {
+        (0, ui_1.fail)(`The organization has ${named.length} connections named ${target}:`);
+        (0, ui_1.table)(named.map((row) => [row.id, row.connector_name ?? row.connector_key ?? '-']));
+        throw new errors_1.CliError('The name is ambiguous', 'Repeat with one of the identifiers above');
+    }
+    throw new errors_1.CliError(`No connection ${target}`, 'What this project can use: xflow connections');
+}
 async function connectionsList() {
     const { config } = (0, config_1.requireProject)();
     const client = (0, session_1.connect)(config);
-    const data = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/connections`);
+    const data = await (0, api_1.apiJson)(client, endpoint(config.projectId));
     if (data.connections.length === 0) {
         (0, ui_1.note)('No connections you can use in this organization');
         (0, ui_1.note)((0, ui_1.dim)('  Somebody connects an account first: platform settings, Connectors'));
@@ -47,6 +77,63 @@ async function connectionsList() {
         (0, ui_1.note)((0, ui_1.dim)('  A change reaches a function on its next deploy: xflow deploy'));
     }
     if (data.connections.some((row) => !row.alias)) {
-        (0, ui_1.note)((0, ui_1.dim)('  To link one: project settings, Connectors. Needs the developer role on the project'));
+        (0, ui_1.note)((0, ui_1.dim)('  To link one: xflow connections link <name> --as ALIAS'));
+    }
+}
+async function connectionsLink(args) {
+    const target = args.words[1];
+    if (!target) {
+        throw new errors_1.CliError('A connection is required', 'Its name is the first column of xflow connections');
+    }
+    // The alias is asked for, never guessed: it becomes the prefix of the
+    // variables, it ends up in the code of the functions, and renaming it later
+    // means editing that code.
+    const alias = (0, args_1.flagString)(args, 'as');
+    if (!alias) {
+        throw new errors_1.CliError('An alias is required', 'For example: xflow connections link "Яндекс Метрика" --as YANDEX_METRIKA');
+    }
+    const { config } = (0, config_1.requireProject)();
+    const client = (0, session_1.connect)(config);
+    const data = await (0, api_1.apiJson)(client, endpoint(config.projectId));
+    const connectionId = resolve(data.connections, target).id;
+    const result = await (0, api_1.apiJson)(client, endpoint(config.projectId), { method: 'POST', body: { connection_id: connectionId, alias } });
+    (0, ui_1.ok)(`${(0, ui_1.bold)(result.label)} linked as ${result.alias}`);
+    if (result.env.length > 0)
+        (0, ui_1.note)((0, ui_1.dim)(`  The functions will get: ${result.env.join(', ')}`));
+    (0, ui_1.note)((0, ui_1.dim)('  The values arrive on the next deploy: xflow deploy'));
+}
+async function connectionsUnlink(args) {
+    const target = args.words[1];
+    if (!target) {
+        throw new errors_1.CliError('A connection is required', 'For example: xflow connections unlink YANDEX_METRIKA');
+    }
+    const { root, config } = (0, config_1.requireProject)();
+    const client = (0, session_1.connect)(config);
+    // The alias is what the code of the functions knows, and it wins: it is the
+    // most precise of the three, since it names the link and not just the account.
+    const data = await (0, api_1.apiJson)(client, endpoint(config.projectId));
+    const byAlias = data.connections.find((item) => item.alias !== null && item.alias === target.toUpperCase());
+    const row = byAlias ?? resolve(data.connections, target);
+    if (!row.alias) {
+        (0, ui_1.note)(`${row.label} is not linked to this project`);
+        return;
+    }
+    // The platform does not see the sources, so this check lives here. Without it
+    // the unlink is silent and the breakage shows up one deploy later.
+    const needed = (0, env_1.referencedByFunctions)(root).needed;
+    const inUse = row.env
+        .map((name) => ({ name, users: needed.get(name) ?? [] }))
+        .filter((entry) => entry.users.length > 0);
+    if (inUse.length > 0 && !(0, args_1.flagBool)(args, 'force')) {
+        (0, ui_1.fail)(`The functions of this project read the variables of ${row.alias}:`);
+        (0, ui_1.table)(inUse.map((entry) => [entry.name, entry.users.join(', ')]));
+        throw new errors_1.CliError('They would lose these variables on the next deploy', 'Repeat with --force if that is intended');
+    }
+    const result = await (0, api_1.apiJson)(client, `${endpoint(config.projectId)}?connection_id=${encodeURIComponent(row.id)}`, { method: 'DELETE' });
+    if (!result.removed) {
+        (0, ui_1.note)(`${row.label} is not linked to this project`);
+        return;
     }
+    (0, ui_1.ok)(`${(0, ui_1.bold)(row.label)} unlinked, ${result.alias} is gone`);
+    (0, ui_1.note)((0, ui_1.dim)('  Functions already deployed keep the values until their next deploy'));
 }

package/dist/commands/deploy.js

@@ -102,7 +102,7 @@ async function startBuild(client, projectId, revision, allowRemovals) {
 }
 async function deploy(args) {
     const { root, config } = (0, config_1.requireProject)();
-    const client = (0, session_1.connect)(config);
+    const client = await (0, session_1.connectProject)(root, config);
     let revision;
     if ((0, args_1.flagBool)(args, 'no-push')) {
         const server = await (0, sources_1.latestRevision)(client, config.projectId);
@@ -148,8 +148,8 @@ async function deploy(args) {
     (0, ui_1.note)((0, ui_1.dim)('  Show it to visitors: xflow publish'));
 }
 async function publish() {
-    const { config } = (0, config_1.requireProject)();
-    const client = (0, session_1.connect)(config);
+    const { root, config } = (0, config_1.requireProject)();
+    const client = await (0, session_1.connectProject)(root, config);
     (0, ui_1.step)('Publishing the current dev version');
     const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/publish`, { method: 'POST', timeoutMs: 120_000 });
     if (result.already_published) {
@@ -161,12 +161,12 @@ async function publish() {
     (0, ui_1.out)(result.project_url);
 }
 async function rollback(args) {
-    const { config } = (0, config_1.requireProject)();
+    const { root, config } = (0, config_1.requireProject)();
     const deployId = args.words[0];
     if (!deployId) {
         throw new errors_1.CliError('A version number is required', 'To see the versions: xflow deployments. For example: xflow rollback 481203');
     }
-    const client = (0, session_1.connect)(config);
+    const client = await (0, session_1.connectProject)(root, config);
     const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/rollback`, { method: 'POST', body: { deploy_id: deployId } });
     (0, ui_1.ok)(`The dev version of the project is switched to ${result.deploy_id}`);
     (0, ui_1.out)(result.project_url);
@@ -176,8 +176,8 @@ async function rollback(args) {
     (0, ui_1.note)((0, ui_1.dim)('  Visitors see it only after xflow publish'));
 }
 async function deployments() {
-    const { config } = (0, config_1.requireProject)();
-    const client = (0, session_1.connect)(config);
+    const { root, config } = (0, config_1.requireProject)();
+    const client = await (0, session_1.connectProject)(root, config);
     const data = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/deployments`);
     if (data.deployments.length === 0) {
         (0, ui_1.note)('No versions yet. To build and release: xflow deploy');

package/dist/commands/env.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.referencedByFunctions = referencedByFunctions;
 exports.envList = envList;
 exports.envCheck = envCheck;
 exports.envSet = envSet;

package/dist/commands/mcp.js

@@ -1,5 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.refreshAgentKey = refreshAgentKey;
 exports.mcpInstall = mcpInstall;
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
@@ -26,6 +27,8 @@ const CLIENTS = [
         ],
         // Re-running must update the entry, not fail on it.
         reset: ['mcp', 'remove', 'xflow', '-s', 'local'],
+        // Succeeds only when an xflow entry is visible from this folder.
+        probe: ['mcp', 'get', 'xflow'],
     },
 ];
 // Output is captured, not inherited: clients may echo the added header together
@@ -33,6 +36,24 @@ const CLIENTS = [
 function hasBinary(binary) {
     return (0, spawn_1.run)(binary, ['--version']).status === 0;
 }
+/**
+ * Rewrite the key in clients that already hold an xflow entry visible from this
+ * folder. Entries are never created here: that stays with xflow mcp install.
+ */
+function refreshAgentKey(client) {
+    const url = `${client.apiUrl.replace(/\/+$/, '')}/api/mcp`;
+    let updated = false;
+    for (const target of CLIENTS) {
+        if (!hasBinary(target.binary))
+            continue;
+        if ((0, spawn_1.run)(target.binary, [...target.probe]).status !== 0)
+            continue;
+        (0, spawn_1.run)(target.binary, [...target.reset]);
+        if ((0, spawn_1.run)(target.binary, target.args(url, client.token)).status === 0)
+            updated = true;
+    }
+    return updated;
+}
 async function mcpInstall(args) {
     // The server covers the organization: the command works outside a project folder too.
     const root = (0, config_1.findProjectRoot)();

package/dist/commands/org.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.orgList = orgList;
+exports.orgSwitch = orgSwitch;
+const config_1 = require("../config");
+const credentials_1 = require("../credentials");
+const errors_1 = require("../errors");
+const ui_1 = require("../ui");
+const mcp_1 = require("./mcp");
+function label(org) {
+    return org.name ?? org.organizationId;
+}
+/** Organizations of this platform address that hold a stored key. */
+function orgList() {
+    const apiUrl = (0, config_1.apiUrlFor)((0, config_1.localConfig)());
+    const orgs = (0, credentials_1.listOrgs)(apiUrl);
+    if (orgs.length === 0) {
+        if ((0, credentials_1.storedKeyInputs)(apiUrl).legacyToken) {
+            (0, ui_1.note)(`One key is stored for ${apiUrl}, its organization is unknown`);
+            (0, ui_1.note)((0, ui_1.dim)('  Sign in again to refresh it: xflow login'));
+        }
+        else {
+            (0, ui_1.note)(`No keys for ${apiUrl}. Sign in: xflow login`);
+        }
+        return;
+    }
+    (0, ui_1.table)(orgs.map((org) => [org.active ? '*' : ' ', org.name ?? '(unnamed)', org.organizationId]));
+    const root = (0, config_1.findProjectRoot)();
+    const boundId = root ? (0, config_1.readState)(root).organizationId : undefined;
+    if (boundId) {
+        const bound = orgs.find((org) => org.organizationId === boundId);
+        (0, ui_1.note)((0, ui_1.dim)(`  This folder is bound to "${bound ? label(bound) : boundId}": commands here stay in it`));
+    }
+    if (orgs.length > 1)
+        (0, ui_1.note)((0, ui_1.dim)('  Switch: xflow org switch <name or id>'));
+    (0, ui_1.note)((0, ui_1.dim)('  To add an organization, sign in to it: xflow login'));
+}
+/** Local switch of the active organization: a pointer move, no browser. */
+function orgSwitch(args) {
+    const wanted = args.words[0];
+    if (!wanted)
+        throw new errors_1.CliError('An organization is required', 'The list: xflow org');
+    const apiUrl = (0, config_1.apiUrlFor)((0, config_1.localConfig)());
+    const orgs = (0, credentials_1.listOrgs)(apiUrl);
+    if (orgs.length === 0) {
+        if ((0, credentials_1.storedKeyInputs)(apiUrl).legacyToken) {
+            throw new errors_1.CliError(`The stored key for ${apiUrl} names no organization`, 'Sign in again to refresh it: xflow login');
+        }
+        throw new errors_1.CliError(`No keys for ${apiUrl}`, 'Sign in: xflow login');
+    }
+    const byId = orgs.find((org) => org.organizationId === wanted);
+    const byName = orgs.filter((org) => (org.name ?? '').toLowerCase() === wanted.toLowerCase());
+    if (!byId && byName.length > 1) {
+        throw new errors_1.CliError(`Several organizations are named "${wanted}"`, `Use the id instead: ${byName.map((org) => org.organizationId).join(', ')}`);
+    }
+    const target = byId ?? byName[0];
+    if (!target) {
+        throw new errors_1.CliError(`No stored key for "${wanted}"`, 'The list: xflow org. To add one: xflow login');
+    }
+    if (target.active) {
+        (0, ui_1.ok)(`"${label(target)}" is already the active organization`);
+        return;
+    }
+    (0, credentials_1.setActiveOrg)(apiUrl, target.organizationId);
+    (0, ui_1.ok)(`Active organization: "${label(target)}"`);
+    const root = (0, config_1.findProjectRoot)();
+    if (root) {
+        // The agent entry of a project folder belongs to the folder's organization,
+        // so the switch leaves it alone.
+        const boundId = (0, config_1.readState)(root).organizationId;
+        if (boundId && boundId !== target.organizationId) {
+            const bound = orgs.find((org) => org.organizationId === boundId);
+            (0, ui_1.note)((0, ui_1.dim)(`  This folder is bound to "${bound ? label(bound) : boundId}": commands here stay in it`));
+        }
+        return;
+    }
+    if ((0, mcp_1.refreshAgentKey)({ apiUrl, token: target.token })) {
+        (0, ui_1.note)((0, ui_1.dim)('  The agent key here is rewritten: restart the agent session to pick it up'));
+    }
+}

package/dist/commands/projects.js

@@ -82,6 +82,8 @@ async function init(args) {
         };
         (0, config_1.writeConfig)(target, config);
         (0, config_1.ignoreStateInGit)(target);
+        if (client.organizationId)
+            (0, config_1.writeState)(target, { organizationId: client.organizationId });
     }
     catch (e) {
         (0, ui_1.note)((0, ui_1.dim)(`  The project "${project.name}" is already created (${project.id}).`));
@@ -100,12 +102,34 @@ async function init(args) {
 async function link(args) {
     const root = (0, config_1.findProjectRoot)() ?? process.cwd();
     const existing = (0, node_fs_1.existsSync)((0, node_path_1.join)(root, config_1.CONFIG_FILE)) ? (0, config_1.readConfig)(root) : undefined;
-    const client = (0, session_1.connect)(existing);
+    let client = (0, session_1.connect)(existing);
     const projectId = args.words[0];
     if (!projectId) {
         throw new errors_1.CliError('A project identifier is required', 'The list: xflow projects list');
     }
-    const card = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}`);
+    let card;
+    try {
+        card = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}`);
+    }
+    catch (e) {
+        // Project ids are unique across the platform, so a 404 under this key does
+        // not mean the project does not exist: another signed-in organization may
+        // hold it. A dead key (401/403) says even less. Ask every stored
+        // organization before giving up.
+        if (!(e instanceof api_1.ApiError && (e.status === 404 || e.status === 401 || e.status === 403)) ||
+            client.source === 'env') {
+            throw e;
+        }
+        const { hit, dead } = await (0, session_1.findProjectOrg)(client.apiUrl, projectId);
+        if (!hit) {
+            throw new errors_1.CliError(`No signed-in organization holds the project ${projectId}`, dead.length > 0
+                ? `The key of ${dead.map((d) => d.name ?? d.organizationId).join(', ')} is not working (sign in again: xflow login); the project may live there`
+                : 'Check the id (xflow projects list), or sign in to the organization that owns it: xflow login');
+        }
+        client = { apiUrl: client.apiUrl, token: hit.token, source: 'folder', organizationId: hit.organizationId };
+        card = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}`);
+        (0, ui_1.note)((0, ui_1.dim)(`  The project belongs to "${hit.name ?? hit.organizationId}", not to the active organization`));
+    }
     const dir = existing ? root : process.cwd();
     (0, config_1.writeConfig)(dir, {
         ...(existing ?? {}),
@@ -113,6 +137,8 @@ async function link(args) {
         build: existing?.build ?? { command: 'npm run build', dir: 'dist' },
     });
     (0, config_1.ignoreStateInGit)(dir);
+    if (client.organizationId)
+        (0, config_1.writeState)(dir, { organizationId: client.organizationId });
     // A fresh clone has no .env: recreate it, never overwrite an existing one.
     if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(dir, '.env')) && card.project_token) {
         write(dir, '.env', (0, template_1.envFile)(card.project_token, client.apiUrl, card.functions));