@vosjs/cli 0.85.0 → 0.87.0

package/dist/{chunk-Q47FUCYN.js → chunk-EXDMMAPT.js}

@@ -3,7 +3,7 @@ import {
   ASSET_ROUTE,
   UsageError,
   serveFile
-} from "./chunk-EPSYIF2S.js";
+} from "./chunk-PEW5GIZF.js";
 
 // src/loadConfig.ts
 import { readFile } from "fs/promises";
@@ -573,4 +573,4 @@ export {
   setFlags,
   applyDataSets
 };
-//# sourceMappingURL=chunk-Q47FUCYN.js.map
+//# sourceMappingURL=chunk-EXDMMAPT.js.map

package/dist/{chunk-EPSYIF2S.js → chunk-PEW5GIZF.js}

@@ -341,9 +341,8 @@ function hasFlag(flags, name) {
 }
 
 // src/plugin/platform.ts
-import { mkdirSync as mkdirSync2, readFileSync, writeFileSync as writeFileSync2 } from "fs";
-import { homedir } from "os";
-import { dirname as dirname2, join } from "path";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 
 // src/plugin/hostAgent.ts
 import { existsSync } from "fs";
@@ -389,6 +388,204 @@ function detectHostAgent(env = process.env, exists = existsSync) {
   return null;
 }
 
+// src/plugin/accounts.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync as writeFileSync2
+} from "fs";
+import { homedir } from "os";
+import { dirname as dirname2, join } from "path";
+var CREDENTIALS_PATH = join(homedir(), ".config", "vos", "credentials");
+var ACCOUNTS_DIR = join(homedir(), ".config", "vos", "accounts");
+var DEFAULT_ORIGIN = "https://vos.so";
+var ACCOUNT_ENV = "VOS_ACCOUNT";
+var DEFAULT_STORE = {
+  credentialsPath: CREDENTIALS_PATH,
+  accountsDir: ACCOUNTS_DIR
+};
+function originOf(url) {
+  try {
+    return new URL(url).origin;
+  } catch {
+    return url.replace(/\/+$/, "");
+  }
+}
+function accountFrom(value) {
+  if (!value || typeof value !== "object") return null;
+  const u = value;
+  if (typeof u.id !== "string" || !u.id) return null;
+  return {
+    id: u.id,
+    kind: u.kind === "org" ? "org" : "person",
+    handle: typeof u.username === "string" && u.username ? u.username : null
+  };
+}
+function formatCredential(c) {
+  const account = c.account ? `account=${c.account.id} ${c.account.kind}${c.account.handle ? ` ${c.account.handle}` : ""}
+` : "";
+  return `${c.key.trim()}
+origin=${originOf(c.origin)}
+${account}`;
+}
+function parseCredential(text) {
+  const [first, ...rest] = text.split("\n");
+  const key = first.trim();
+  if (!key) return null;
+  let origin = "";
+  let account = null;
+  for (const raw of rest) {
+    const line = raw.trim();
+    if (line.startsWith("origin=")) origin = originOf(line.slice(7).trim());
+    else if (line.startsWith("account=")) {
+      const [id, kind, handle] = line.slice(8).trim().split(/\s+/);
+      if (id)
+        account = {
+          id,
+          kind: kind === "org" ? "org" : "person",
+          handle: handle || null
+        };
+    }
+  }
+  return { key, origin: origin || DEFAULT_ORIGIN, account };
+}
+function readFile(path) {
+  try {
+    return parseCredential(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function writeFile2(path, c) {
+  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
+  writeFileSync2(path, formatCredential(c), { mode: 384 });
+}
+function hostDir(origin) {
+  let host;
+  try {
+    host = new URL(origin).host;
+  } catch {
+    host = origin.replace(/^https?:\/\//, "").replace(/\/.*$/, "");
+  }
+  return host.replace(/[^A-Za-z0-9.-]/g, "_") || "unknown";
+}
+function accountPath(store, origin, accountId) {
+  return join(store.accountsDir, hostDir(origin), accountId);
+}
+function readActive(store = DEFAULT_STORE) {
+  return readFile(store.credentialsPath);
+}
+function listStored(store = DEFAULT_STORE, origin) {
+  const active = readActive(store);
+  const want = origin ? originOf(origin) : null;
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push = (c) => {
+    if (!c || want && c.origin !== want || seen.has(c.key)) return;
+    seen.add(c.key);
+    out.push(c);
+  };
+  push(active);
+  let hosts = [];
+  try {
+    hosts = readdirSync(store.accountsDir);
+  } catch {
+    return out;
+  }
+  for (const host of hosts.sort()) {
+    let files = [];
+    try {
+      files = readdirSync(join(store.accountsDir, host));
+    } catch {
+      continue;
+    }
+    for (const file of files.sort()) {
+      push(readFile(join(store.accountsDir, host, file)));
+    }
+  }
+  return out;
+}
+function isActive(c, store = DEFAULT_STORE) {
+  return readActive(store)?.key === c.key;
+}
+function accountLabel(a) {
+  if (!a) return "an unnamed account";
+  return a.handle ? `@${a.handle}` : a.id;
+}
+function matchesAccount(a, ref) {
+  if (!a) return false;
+  const want = ref.trim().replace(/^@/, "");
+  if (!want) return false;
+  if (a.id === want) return true;
+  return !!a.handle && a.handle.toLowerCase() === want.toLowerCase();
+}
+function findStored(store, origin, ref) {
+  return listStored(store, origin).find((c) => matchesAccount(c.account, ref)) ?? null;
+}
+function activate(store, c) {
+  writeFile2(store.credentialsPath, c);
+  return store.credentialsPath;
+}
+function storeCredential(store, c) {
+  const previous = readActive(store);
+  let setAside = null;
+  if (previous && previous.key !== c.key) {
+    if (previous.account) {
+      writeFile2(
+        accountPath(store, previous.origin, previous.account.id),
+        previous
+      );
+      setAside = previous;
+    }
+  }
+  if (c.account) writeFile2(accountPath(store, c.origin, c.account.id), c);
+  return { path: activate(store, c), setAside };
+}
+function removeStored(store, c) {
+  const wasActive = isActive(c, store);
+  if (c.account) {
+    rmSync(accountPath(store, c.origin, c.account.id), { force: true });
+  }
+  if (wasActive) rmSync(store.credentialsPath, { force: true });
+  return { wasActive };
+}
+function removeAll(store) {
+  const had = existsSync2(store.credentialsPath) || existsSync2(store.accountsDir);
+  rmSync(store.credentialsPath, { force: true });
+  rmSync(store.accountsDir, { recursive: true, force: true });
+  return { had };
+}
+function switchTarget(stored, activeKey, ref, origin) {
+  if (ref) {
+    const to = stored.find((c) => matchesAccount(c.account, ref));
+    if (!to)
+      return {
+        ok: false,
+        error: `no credential stored for ${ref.startsWith("@") ? ref : `@${ref.replace(/^@/, "")}`} on ${origin}; run vos login and approve as it${stored.length ? `, or vos switch ${stored.map((c) => accountLabel(c.account)).join(" | ")}` : ""}`
+      };
+    return { ok: true, to };
+  }
+  const others = stored.filter((c) => c.key !== activeKey);
+  if (stored.length === 0)
+    return {
+      ok: false,
+      error: `nothing is stored for ${origin}; run vos login`
+    };
+  if (stored.length === 1)
+    return {
+      ok: false,
+      error: `only ${accountLabel(stored[0].account)} is stored for ${origin}; run vos login and approve as another account to add one`
+    };
+  if (others.length === 1) return { ok: true, to: others[0] };
+  return {
+    ok: false,
+    error: `say which: vos switch ${stored.map((c) => accountLabel(c.account)).join(" | ")}`
+  };
+}
+
 // src/plugin/platform.ts
 function platformOrigin(flags = {}) {
   const legacyEnv = process.env.VOS_API_BASE?.trim();
@@ -422,40 +619,116 @@ function parseVosId(input) {
 function deriveSlug(title) {
   return title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 50).replace(/-+$/, "") || "remix";
 }
-var CREDENTIALS_PATH = join(homedir(), ".config", "vos", "credentials");
-var DEFAULT_ORIGIN = "https://vos.so";
-function originOf(url) {
-  try {
-    return new URL(url).origin;
-  } catch {
-    return url.replace(/\/+$/, "");
-  }
+var storedFor = /* @__PURE__ */ new Map();
+var warned = /* @__PURE__ */ new Set();
+var lastResolved = null;
+function lastCredential() {
+  return lastResolved;
 }
-function readStoredCredential(path = CREDENTIALS_PATH) {
-  let text;
-  try {
-    text = readFileSync(path, "utf8");
-  } catch {
-    return null;
+function directoryVerdict(state, origin, stored, dir) {
+  if (!state?.account) return { kind: "none" };
+  if (state.origin && originOf(state.origin) !== originOf(origin)) {
+    return {
+      kind: "other-origin",
+      note: `note: ${dir} was last pushed to ${state.origin}, and this command goes to ${originOf(origin)}`
+    };
   }
-  const [first, ...rest] = text.split("\n");
-  const key = first.trim();
-  if (!key) return null;
-  const line = rest.map((l) => l.trim()).find((l) => l.startsWith("origin="));
-  const origin = line ? originOf(line.slice("origin=".length).trim()) : "";
-  return { key, origin: origin || DEFAULT_ORIGIN };
+  if (stored) return { kind: "use", credential: stored };
+  const name = state.account.handle ? `@${state.account.handle}` : state.account.id;
+  const ref = state.account.handle ?? state.account.id;
+  return {
+    kind: "missing",
+    error: `${dir} belongs to ${name}, and no credential for it is stored for ${originOf(origin)}. Run vos login and approve as ${name}, or vos switch ${ref} if it is stored under another name, or pass --account or --key.`
+  };
+}
+function credentialFlags(flags) {
+  const str = (name) => typeof flags[name] === "string" ? flags[name] : void 0;
+  return {
+    key: str("key"),
+    account: str("account"),
+    origin: platformOrigin({ origin: str("origin"), api: str("api") })
+  };
+}
+function fromStore(c, via) {
+  if (!c) return null;
+  storedFor.set(c.key, c.origin);
+  lastResolved = { key: c.key, via, account: c.account, origin: c.origin };
+  return c.key;
 }
-var storedFor = /* @__PURE__ */ new Map();
-var warned = /* @__PURE__ */ new Set();
 function resolveCredential(explicit, path = CREDENTIALS_PATH) {
-  const flag = explicit?.trim();
-  if (flag) return flag;
+  const ask = typeof explicit === "string" || explicit === void 0 ? { key: explicit } : explicit;
+  const store = ask.store ?? {
+    ...DEFAULT_STORE,
+    ...path !== CREDENTIALS_PATH ? { credentialsPath: path } : {}
+  };
+  const origin = ask.origin ?? platformOrigin();
+  const flag = ask.key?.trim();
+  if (flag) {
+    lastResolved = { key: flag, via: "flag", account: null, origin: null };
+    return flag;
+  }
+  const named = ask.account?.trim();
+  if (named) {
+    const found = findStored(store, origin, named);
+    if (!found)
+      throw new Error(noSuchAccount(store, origin, named, "--account"));
+    return fromStore(found, "account-flag");
+  }
   const env = process.env.VOS_API_KEY?.trim();
-  if (env) return env;
-  const stored = readStoredCredential(path);
-  if (!stored) return null;
-  storedFor.set(stored.key, stored.origin);
-  return stored.key;
+  if (env) {
+    lastResolved = { key: env, via: "env", account: null, origin: null };
+    return env;
+  }
+  const envName = process.env[ACCOUNT_ENV]?.trim();
+  if (envName) {
+    const found = findStored(store, origin, envName);
+    if (!found)
+      throw new Error(noSuchAccount(store, origin, envName, ACCOUNT_ENV));
+    return fromStore(found, "account-env");
+  }
+  if (ask.dir) {
+    const state = readSyncState(ask.dir);
+    const verdict = directoryVerdict(
+      state,
+      origin,
+      state?.account ? findStored(store, origin, state.account.id) : null,
+      ask.dir
+    );
+    if (verdict.kind === "use")
+      return fromStore(verdict.credential, "directory");
+    if (verdict.kind === "missing") throw new Error(verdict.error);
+    if (verdict.kind === "other-origin" && !warned.has(verdict.note)) {
+      warned.add(verdict.note);
+      process.stderr.write(`${verdict.note}
+`);
+    }
+  }
+  return fromStore(readActive(store), "stored");
+}
+var accountOfKey = /* @__PURE__ */ new Map();
+function credentialAccount(origin, key) {
+  const last = lastResolved;
+  if (last && last.key === key && last.account)
+    return Promise.resolve(last.account);
+  const id = `${originOf(origin)} ${key}`;
+  let pending = accountOfKey.get(id);
+  if (!pending) {
+    pending = apiJson(origin, "/api/user/whoami", { key }).then((res) => res.status === 200 ? accountFrom(res.body.user) : null).catch(() => null);
+    accountOfKey.set(id, pending);
+  }
+  return pending;
+}
+async function syncIdentity(origin, key) {
+  const account = key ? await credentialAccount(origin, key) : null;
+  return {
+    origin: originOf(origin),
+    ...account ? { account: { id: account.id, handle: account.handle } } : {}
+  };
+}
+function noSuchAccount(store, origin, ref, how) {
+  const have = listStored(store, origin).map((c) => accountLabel(c.account));
+  const name = ref.startsWith("@") ? ref : `@${ref}`;
+  return `${how} names ${name}, and no credential for it is stored for ${origin}: run vos login and approve as ${name}` + (have.length ? ` (stored: ${have.join(", ")})` : "");
 }
 function bearerFor(key, url) {
   if (!key) return {};
@@ -477,20 +750,25 @@ var mintAt = (origin = DEFAULT_ORIGIN) => `${originOf(origin)}/app/api`;
 function requireCredential(explicit, origin) {
   const key = resolveCredential(explicit);
   if (!key) {
+    const at = origin ?? (typeof explicit === "object" ? explicit.origin : void 0) ?? platformOrigin();
     throw new Error(
-      `no credential found \u2014 pass --key, set VOS_API_KEY, or run \`vos login\` (mint a content key at ${mintAt(origin ?? platformOrigin())}; a vos_rg_ remix grant works too)`
+      `no credential found \u2014 pass --key, set VOS_API_KEY, or run \`vos login\` (mint a content key at ${mintAt(at)}; a vos_rg_ remix grant works too)`
     );
   }
   return key;
 }
-function writeCredential(key, origin = DEFAULT_ORIGIN, path = CREDENTIALS_PATH) {
-  mkdirSync2(dirname2(path), { recursive: true, mode: 448 });
-  writeFileSync2(path, `${key.trim()}
-origin=${originOf(origin)}
-`, {
-    mode: 384
+function writeCredential(key, origin = DEFAULT_ORIGIN, path = CREDENTIALS_PATH, account = null) {
+  return storeLogin(key, origin, account, {
+    ...DEFAULT_STORE,
+    ...path !== CREDENTIALS_PATH ? { credentialsPath: path } : {}
+  }).path;
+}
+function storeLogin(key, origin, account, store = DEFAULT_STORE) {
+  return storeCredential(store, {
+    key: key.trim(),
+    origin: originOf(origin),
+    account
   });
-  return path;
 }
 function clientId(env = process.env, exists) {
   const explicit = env.VOS_CLIENT?.trim();
@@ -548,6 +826,12 @@ function promptHint(target, vosId) {
   return `vos push ${target} --vos ${vosId} --prompt "<the person's prompt, as they wrote it>"`;
 }
 var SYNC_STATE_NAME = "vos.json";
+function syncAccountOf(value) {
+  if (!value || typeof value !== "object") return void 0;
+  const a = value;
+  if (typeof a.id !== "string" || !a.id) return void 0;
+  return { id: a.id, handle: typeof a.handle === "string" ? a.handle : null };
+}
 function hostedMediaOf(value) {
   if (!value || typeof value !== "object") return void 0;
   const out = {};
@@ -560,13 +844,13 @@ function hostedMediaOf(value) {
 }
 function readJsonFile(file) {
   try {
-    return JSON.parse(readFileSync(file, "utf8"));
+    return JSON.parse(readFileSync2(file, "utf8"));
   } catch {
     return null;
   }
 }
 function readSyncState(dir) {
-  const own = readJsonFile(join(dir, SYNC_STATE_NAME));
+  const own = readJsonFile(join2(dir, SYNC_STATE_NAME));
   if (own && typeof own.vosId === "string") {
     return {
       vosId: own.vosId,
@@ -575,10 +859,12 @@ function readSyncState(dir) {
       ...typeof own.title === "string" ? { title: own.title } : {},
       ...typeof own.slug === "string" ? { slug: own.slug } : {},
       ...typeof own.remixOfId === "string" ? { remixOfId: own.remixOfId } : {},
-      ...hostedMediaOf(own.hostedMedia) ? { hostedMedia: hostedMediaOf(own.hostedMedia) } : {}
+      ...hostedMediaOf(own.hostedMedia) ? { hostedMedia: hostedMediaOf(own.hostedMedia) } : {},
+      ...typeof own.origin === "string" && own.origin ? { origin: originOf(own.origin) } : {},
+      ...syncAccountOf(own.account) ? { account: syncAccountOf(own.account) } : {}
     };
   }
-  const push = readJsonFile(join(dir, "push.json"));
+  const push = readJsonFile(join2(dir, "push.json"));
   if (push && typeof push.vosId === "string") {
     return {
       vosId: push.vosId,
@@ -586,7 +872,7 @@ function readSyncState(dir) {
       ...typeof push.pushedAt === "string" ? { pushedAt: push.pushedAt } : {}
     };
   }
-  const meta = readJsonFile(join(dir, "meta.json"));
+  const meta = readJsonFile(join2(dir, "meta.json"));
   if (meta && typeof meta.id === "string") {
     return {
       vosId: meta.id,
@@ -604,7 +890,7 @@ function writeSyncState(dir, patch) {
     ...patch
   };
   writeFileSafeSync(
-    join(dir, SYNC_STATE_NAME),
+    join2(dir, SYNC_STATE_NAME),
     `${JSON.stringify(merged, null, 2)}
 `
   );
@@ -631,19 +917,19 @@ function serverWarnings(body, log) {
 import { createHash } from "crypto";
 import {
   closeSync,
-  existsSync as existsSync2,
+  existsSync as existsSync3,
   mkdirSync as mkdirSync3,
   openSync,
   readSync,
-  readdirSync,
+  readdirSync as readdirSync2,
   realpathSync,
   renameSync,
-  rmSync,
+  rmSync as rmSync2,
   statSync,
   writeFileSync as writeFileSync3
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { extname, join as join2, resolve, sep } from "path";
+import { extname, join as join3, resolve, sep } from "path";
 var ASSET_ROUTE = "/__assets/";
 var UUID = "[0-9a-f]{8}(?:-[0-9a-f]{4}){3}-[0-9a-f]{12}";
 var HOSTED_URI = new RegExp(`^asset:(${UUID})$`);
@@ -729,7 +1015,7 @@ function localFile(ref, baseDir) {
     };
   }
   const file = resolve(baseDir, ref);
-  if (!existsSync2(file) || !statSync(file).isFile()) {
+  if (!existsSync3(file) || !statSync(file).isFile()) {
     return { refused: "which is not a file beside the config" };
   }
   const root = realpathSync(baseDir);
@@ -765,11 +1051,11 @@ function manifestRefs(config) {
   return out;
 }
 async function fetchHosted(id, opts) {
-  const dir = opts.cacheDir ?? join2(homedir2(), ".cache", "vos", "assets");
-  const cached = existsSync2(dir) ? readdirSync(dir).find(
+  const dir = opts.cacheDir ?? join3(homedir2(), ".cache", "vos", "assets");
+  const cached = existsSync3(dir) ? readdirSync2(dir).find(
     (f) => (f === id || f.startsWith(`${id}.`)) && !f.endsWith(".part")
   ) : void 0;
-  if (cached) return join2(dir, cached);
+  if (cached) return join3(dir, cached);
   if (!opts.origin || !opts.key) {
     opts.log(
       `note: asset ${id} is hosted and no credential is set, so the render cannot load it (vos login, or keep the file beside the config and name its path)`
@@ -787,7 +1073,7 @@ async function fetchHosted(id, opts) {
   }
   mkdirSync3(dir, { recursive: true, mode: 448 });
   const type = (res.headers.get("content-type") ?? "").split(";")[0].trim();
-  const file = join2(dir, `${id}${extensionFor(type)}`);
+  const file = join3(dir, `${id}${extensionFor(type)}`);
   const partial = `${file}.part`;
   try {
     writeFileSync3(partial, new Uint8Array(await res.arrayBuffer()), {
@@ -795,7 +1081,7 @@ async function fetchHosted(id, opts) {
     });
     renameSync(partial, file);
   } finally {
-    rmSync(partial, { force: true });
+    rmSync2(partial, { force: true });
   }
   return file;
 }
@@ -920,11 +1206,28 @@ export {
   numFlag2,
   strFlag,
   hasFlag,
+  CREDENTIALS_PATH,
+  ACCOUNT_ENV,
+  DEFAULT_STORE,
+  originOf,
+  accountFrom,
+  readActive,
+  listStored,
+  isActive,
+  accountLabel,
+  findStored,
+  activate,
+  removeStored,
+  removeAll,
+  switchTarget,
   platformOrigin,
   parseVosId,
   deriveSlug,
-  CREDENTIALS_PATH,
+  lastCredential,
+  credentialFlags,
   resolveCredential,
+  credentialAccount,
+  syncIdentity,
   bearerFor,
   mintAt,
   requireCredential,
@@ -947,4 +1250,4 @@ export {
   programAssets,
   missingManifestFiles
 };
-//# sourceMappingURL=chunk-EPSYIF2S.js.map
+//# sourceMappingURL=chunk-PEW5GIZF.js.map