@getxflow/cli 0.6.5 → 0.7.0

package/dist/commands/sources.js

@@ -79,7 +79,11 @@ async function pushSources(root, config, client, options) {
     // a mismatch must not overwrite silently.
     if (server && state.revision === undefined && !options.force) {
         if (server.tree_hash === tree.hash) {
-            (0, config_1.writeState)(root, { revision: server.revision, treeHash: server.tree_hash });
+            (0, config_1.writeState)(root, {
+                revision: server.revision,
+                treeHash: server.tree_hash,
+                organizationId: client.organizationId ?? undefined,
+            });
             (0, ui_1.ok)(`Already in sync, revision ${server.revision}`);
             return { revision: server.revision, status: 'unchanged' };
         }
@@ -94,7 +98,11 @@ async function pushSources(root, config, client, options) {
     if (options.force)
         headers['X-Force'] = 'true';
     const result = await (0, api_1.apiUpload)(client, `/api/v1/projects/${config.projectId}/push`, tree.archive, headers);
-    (0, config_1.writeState)(root, { revision: result.revision, treeHash: result.tree_hash });
+    (0, config_1.writeState)(root, {
+        revision: result.revision,
+        treeHash: result.tree_hash,
+        organizationId: client.organizationId ?? undefined,
+    });
     if (result.status === 'unchanged') {
         (0, ui_1.ok)(`No changes, revision ${result.revision}`);
     }
@@ -105,7 +113,7 @@ async function pushSources(root, config, client, options) {
 }
 async function push(args) {
     const { root, config } = (0, config_1.requireProject)();
-    const client = (0, session_1.connect)(config);
+    const client = await (0, session_1.connectProject)(root, config);
     await pushSources(root, config, client, { force: (0, args_1.flagBool)(args, 'force') });
 }
 function hasContent(dir) {
@@ -117,7 +125,7 @@ async function pull(args) {
     const { root, config } = (0, config_1.requireProject)();
     const into = (0, args_1.flagString)(args, 'into');
     const target = into ? (0, node_path_1.resolve)(into) : root;
-    const client = (0, session_1.connect)(config);
+    const client = await (0, session_1.connectProject)(root, config);
     const revision = (0, args_1.flagNumber)(args, 'revision');
     const query = revision !== undefined ? `?revision=${revision}` : '';
     const info = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/pull${query}`);
@@ -139,13 +147,17 @@ async function pull(args) {
     }
     // Only the working folder tracks revisions; a side copy (--into) must not reset them.
     if (!into) {
-        (0, config_1.writeState)(root, { revision: info.revision, treeHash: info.tree_hash });
+        (0, config_1.writeState)(root, {
+            revision: info.revision,
+            treeHash: info.tree_hash,
+            organizationId: client.organizationId ?? undefined,
+        });
     }
     (0, ui_1.ok)(`Revision ${info.revision}: ${entries.length} files in ${target}`);
 }
 async function status() {
     const { root, config } = (0, config_1.requireProject)();
-    const client = (0, session_1.connect)(config);
+    const client = await (0, session_1.connectProject)(root, config);
     const tree = prepareTree(root, config);
     const state = (0, config_1.readState)(root);
     const [card, server] = await Promise.all([

package/dist/config.js

@@ -4,6 +4,7 @@ exports.ConfigError = exports.CONFIG_FILE = void 0;
 exports.findProjectRoot = findProjectRoot;
 exports.readConfig = readConfig;
 exports.writeConfig = writeConfig;
+exports.localConfig = localConfig;
 exports.requireProject = requireProject;
 exports.apiUrlFor = apiUrlFor;
 exports.readState = readState;
@@ -47,6 +48,18 @@ function readConfig(root) {
 function writeConfig(root, config) {
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, exports.CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
 }
+/** The config of the folder we are in, when there is one and it parses. */
+function localConfig() {
+    const root = findProjectRoot();
+    if (!root)
+        return undefined;
+    try {
+        return readConfig(root);
+    }
+    catch {
+        return undefined;
+    }
+}
 function requireProject() {
     const root = findProjectRoot();
     if (!root) {
@@ -75,9 +88,15 @@ function readState(root) {
         return {};
     }
 }
-function writeState(root, state) {
+/** Merge, never replace: callers write their own fields, the rest survives. */
+function writeState(root, patch) {
     const dir = (0, node_path_1.join)(root, STATE_DIR);
     (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const state = { ...readState(root) };
+    for (const [key, value] of Object.entries(patch)) {
+        if (value !== undefined)
+            state[key] = value;
+    }
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(dir, 'state.json'), `${JSON.stringify(state, null, 2)}\n`, 'utf-8');
 }
 /** Keep .xflow/ out of git. */

package/dist/credentials.js

@@ -1,9 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.saveCredential = saveCredential;
-exports.forgetCredential = forgetCredential;
-exports.resolveToken = resolveToken;
-exports.readCredential = readCredential;
+exports.reconcile = reconcile;
+exports.listOrgs = listOrgs;
+exports.saveOrgCredential = saveOrgCredential;
+exports.rememberOrgName = rememberOrgName;
+exports.setActiveOrg = setActiveOrg;
+exports.forgetOrg = forgetOrg;
+exports.forgetAllOrgs = forgetAllOrgs;
+exports.anyMultipleOrgs = anyMultipleOrgs;
+exports.pickKey = pickKey;
+exports.storedKeyInputs = storedKeyInputs;
 const node_fs_1 = require("node:fs");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
@@ -38,28 +44,208 @@ function writeStore(store) {
         // Windows has no POSIX modes.
     }
 }
-function saveCredential(apiUrl, credential) {
+function isLegacy(value) {
+    return !!value && typeof value.token === 'string';
+}
+/** The mirror for older CLIs: the key of the active organization, or nothing. */
+function syncLegacy(store, apiUrl) {
+    const address = store.orgs?.[apiUrl];
+    if (!address)
+        return;
+    const active = address.active ? address.keys[address.active] : undefined;
+    if (active && address.active) {
+        store[apiUrl] = { token: active.token, organizationId: address.active, savedAt: active.savedAt };
+        address.mirror = address.active;
+    }
+    else {
+        delete store[apiUrl];
+        address.mirror = null;
+    }
+}
+/**
+ * Fold writes made by an older CLI back into the map. Its login rewrites only
+ * the mirror record, its logout deletes only it; both are treated as what the
+ * person meant: "sign in to this organization" and "forget the key I am using".
+ * Returns true when the store changed and has to be written back.
+ */
+function reconcile(store, apiUrl) {
+    const legacy = store[apiUrl];
+    let address = store.orgs?.[apiUrl];
+    let changed = false;
+    if (isLegacy(legacy) && legacy.organizationId) {
+        const orgs = address ?? { active: null, keys: {} };
+        const known = orgs.keys[legacy.organizationId];
+        if (!known || known.token !== legacy.token || orgs.active !== legacy.organizationId) {
+            orgs.keys[legacy.organizationId] = { ...known, token: legacy.token, savedAt: legacy.savedAt };
+            orgs.active = legacy.organizationId;
+            store.orgs = store.orgs ?? {};
+            store.orgs[apiUrl] = orgs;
+            address = orgs;
+            changed = true;
+        }
+    }
+    if (!isLegacy(legacy) && address?.active && address.keys[address.active]) {
+        if (address.mirror === address.active) {
+            // The mirror we wrote for this key is gone: an older CLI logged out.
+            delete address.keys[address.active];
+            address.active = null;
+        }
+        // Otherwise no mirror was ever written for this key (a hand-made or
+        // restored file): deleting it would lose a key nobody asked to forget.
+        // Either way the store changed: the mirror has to be rebuilt.
+        changed = true;
+    }
+    // The pointer must land on a stored key, or on nothing.
+    if (address) {
+        const ids = Object.keys(address.keys);
+        const active = address.active && address.keys[address.active] ? address.active : (ids[0] ?? null);
+        if (address.active !== active) {
+            address.active = active;
+            changed = true;
+        }
+    }
+    if (changed)
+        syncLegacy(store, apiUrl);
+    return changed;
+}
+/** Read the store with the drift of older CLIs healed, persisting the healing. */
+function load(apiUrl) {
     const store = readStore();
-    store[apiUrl] = { ...credential, savedAt: new Date().toISOString() };
+    if (reconcile(store, apiUrl))
+        commit(store, apiUrl);
+    return store;
+}
+function commit(store, apiUrl) {
+    syncLegacy(store, apiUrl);
+    const address = store.orgs?.[apiUrl];
+    if (address && Object.keys(address.keys).length === 0) {
+        delete store.orgs?.[apiUrl];
+        if (store.orgs && Object.keys(store.orgs).length === 0)
+            delete store.orgs;
+    }
     writeStore(store);
 }
-function forgetCredential(apiUrl) {
+/** Organizations with a stored key for the address, the active one first. */
+function listOrgs(apiUrl) {
+    const address = load(apiUrl).orgs?.[apiUrl];
+    if (!address)
+        return [];
+    return Object.entries(address.keys)
+        .map(([organizationId, key]) => ({
+        organizationId,
+        name: key.name ?? null,
+        token: key.token,
+        active: organizationId === address.active,
+    }))
+        .sort((a, b) => Number(b.active) - Number(a.active));
+}
+/** Store the key and make its organization the active one. */
+function saveOrgCredential(apiUrl, organizationId, token, name) {
+    const store = readStore();
+    reconcile(store, apiUrl);
+    const orgs = store.orgs?.[apiUrl] ?? { active: null, keys: {} };
+    const known = orgs.keys[organizationId];
+    orgs.keys[organizationId] = {
+        token,
+        name: name ?? known?.name ?? null,
+        savedAt: new Date().toISOString(),
+    };
+    orgs.active = organizationId;
+    store.orgs = store.orgs ?? {};
+    store.orgs[apiUrl] = orgs;
+    commit(store, apiUrl);
+}
+/** Cache the display name; a stale one is refreshed by any login or whoami. */
+function rememberOrgName(apiUrl, organizationId, name) {
     const store = readStore();
-    if (!store[apiUrl])
+    reconcile(store, apiUrl);
+    const entry = store.orgs?.[apiUrl]?.keys[organizationId];
+    if (!entry || entry.name === name)
+        return;
+    entry.name = name;
+    commit(store, apiUrl);
+}
+function setActiveOrg(apiUrl, organizationId) {
+    const store = readStore();
+    reconcile(store, apiUrl);
+    const orgs = store.orgs?.[apiUrl];
+    if (!orgs?.keys[organizationId])
+        return false;
+    if (orgs.active !== organizationId) {
+        orgs.active = organizationId;
+        commit(store, apiUrl);
+    }
+    return true;
+}
+/** Forget one organization; the pointer moves to any remaining one. */
+function forgetOrg(apiUrl, organizationId) {
+    const store = readStore();
+    reconcile(store, apiUrl);
+    const orgs = store.orgs?.[apiUrl];
+    if (!orgs?.keys[organizationId])
+        return { removed: false, nextActive: null };
+    delete orgs.keys[organizationId];
+    if (orgs.active === organizationId)
+        orgs.active = Object.keys(orgs.keys)[0] ?? null;
+    commit(store, apiUrl);
+    const next = orgs.active ? orgs.keys[orgs.active] : undefined;
+    return {
+        removed: true,
+        nextActive: next && orgs.active
+            ? { organizationId: orgs.active, name: next.name ?? null, token: next.token, active: true }
+            : null,
+    };
+}
+/** Forget every key of the address; other addresses are untouched. */
+function forgetAllOrgs(apiUrl) {
+    const store = readStore();
+    reconcile(store, apiUrl);
+    const had = !!store.orgs?.[apiUrl] || isLegacy(store[apiUrl]);
+    if (!had)
         return false;
+    if (store.orgs) {
+        delete store.orgs[apiUrl];
+        if (Object.keys(store.orgs).length === 0)
+            delete store.orgs;
+    }
     delete store[apiUrl];
     writeStore(store);
     return true;
 }
-/** XFLOW_TOKEN wins over the store; the caller decides whether env is allowed for this address. */
-function resolveToken(apiUrl, allowEnv = true) {
-    if (allowEnv) {
-        const fromEnv = process.env.XFLOW_TOKEN?.trim();
-        if (fromEnv)
-            return fromEnv;
+/** True when any address holds keys of more than one organization. */
+function anyMultipleOrgs() {
+    const store = readStore();
+    return Object.values(store.orgs ?? {}).some((address) => Object.keys(address.keys).length > 1);
+}
+/**
+ * One rule for the whole CLI: XFLOW_TOKEN (default address only) beats the
+ * folder's organization, which beats the active one. A folder bound to an
+ * organization without a stored key is an error, not a fallback: the command
+ * would silently run against a different organization.
+ */
+function pickKey(inputs) {
+    if (inputs.envAllowed && inputs.env)
+        return { token: inputs.env, source: 'env', organizationId: null };
+    if (inputs.folderOrg) {
+        const key = inputs.orgs?.keys[inputs.folderOrg];
+        if (key)
+            return { token: key.token, source: 'folder', organizationId: inputs.folderOrg };
+        return { missing: 'folder-key', organizationId: inputs.folderOrg };
     }
-    return readStore()[apiUrl]?.token ?? null;
+    const activeId = inputs.orgs?.active;
+    const active = activeId ? inputs.orgs?.keys[activeId] : undefined;
+    if (active && activeId)
+        return { token: active.token, source: 'active', organizationId: activeId };
+    if (inputs.legacyToken)
+        return { token: inputs.legacyToken, source: 'active', organizationId: null };
+    return null;
 }
-function readCredential(apiUrl) {
-    return readStore()[apiUrl] ?? null;
+/** The store-backed half of pickKey's inputs; the caller adds env and the folder binding. */
+function storedKeyInputs(apiUrl) {
+    const store = load(apiUrl);
+    const legacy = store[apiUrl];
+    return {
+        orgs: store.orgs?.[apiUrl] ?? null,
+        legacyToken: isLegacy(legacy) ? legacy.token : null,
+    };
 }