@craftspace/cli 0.9.1 → 0.10.0

package/dist/machine.d.ts

@@ -1,12 +1,14 @@
 import { type Machine } from '@craftspace/shared';
+import { z } from 'zod';
 export declare const machine: {
-    home(): string;
+    root(): string;
+    seats(): Promise<Seat[]>;
     login({ token, url, install }: {
         token: string;
         url: string;
         install: boolean;
-    }): Promise<Machine>;
-    workDir(): Promise<string | null>;
+    }): Promise<SignedIn>;
+    workDir(organization: string): Promise<string>;
     controlPlane(override?: string): Promise<string>;
     signIn({ url, why, install }: {
         url?: string;
@@ -16,8 +18,13 @@ export declare const machine: {
     status(): Promise<{
         machine: Machine;
         url: string;
-    }>;
-    beatOnce(say?: (line: string) => void): Promise<boolean>;
+        organization: string;
+    }[]>;
+    beatAll(say?: (line: string) => void): Promise<boolean>;
+    beatOnce({ home, say }: {
+        home: string;
+        say?: (line: string) => void;
+    }): Promise<boolean>;
     beatForever(): Promise<void>;
     run(): Promise<number>;
     daemon(): Promise<{
@@ -28,6 +35,12 @@ export declare const machine: {
 };
 export declare function portableTerm(local: string | undefined): string;
 export declare function tokenIn(line: string): string | undefined;
+export declare function replaceBlock({ text, begin, end, block, }: {
+    text: string;
+    begin: string;
+    end: string;
+    block: string;
+}): string;
 export declare function nextDelayMs(failures: number, busy?: boolean): number;
 interface Auth {
     url: string;
@@ -35,5 +48,17 @@ interface Auth {
 }
 interface SignedIn extends Auth {
     machine: Machine;
+    organization: string;
+}
+export interface Seat {
+    home: string;
+    config: Config;
 }
+type Config = z.infer<typeof ConfigSchema>;
+declare const ConfigSchema: z.ZodObject<{
+    url: z.ZodString;
+    machineId: z.ZodString;
+    organization: z.ZodOptional<z.ZodString>;
+    account: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
 export {};

package/dist/machine.js

@@ -1,6 +1,6 @@
 import { execFile, spawn } from 'node:child_process';
 import { existsSync } from 'node:fs';
-import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
@@ -15,9 +15,24 @@ import { ui } from './ui.js';
 import { isNewer, update } from './update.js';
 const run = promisify(execFile);
 export const machine = {
-    home() {
+    root() {
         return process.env.CRAFTSPACE_CLI_HOME ?? path.join(os.homedir(), '.craftspace');
     },
+    async seats() {
+        await settleLayout();
+        const entries = await readdir(machine.root(), { withFileTypes: true }).catch(() => []);
+        const seats = [];
+        for (const entry of entries.filter((found) => found.isDirectory())) {
+            const home = path.join(machine.root(), entry.name);
+            const config = await readConfig(home);
+            if (config !== null)
+                seats.push({ home, config });
+        }
+        const legacy = await readConfig(machine.root());
+        if (legacy !== null)
+            seats.push({ home: machine.root(), config: legacy });
+        return seats;
+    },
     async login({ token, url, install }) {
         const answer = await call({
             url,
@@ -35,26 +50,29 @@ export const machine = {
             },
             schema: MachineLoginResponseSchema,
         });
-        await mkdir(machine.home(), { recursive: true, mode: 0o700 });
-        await writeConfig({ url, machineId: answer.machine.id, organization: toSpaceSlug(answer.organizationName) });
-        await writeFile(tokenPath(), token, { mode: 0o600 });
+        const organization = toSpaceSlug(answer.organizationName) || 'team';
+        const account = answer.machine.ownerAccountId;
+        await refuseSecondAccount({ account, organization });
+        const home = path.join(machine.root(), organization);
+        await mkdir(home, { recursive: true, mode: 0o700 });
+        await writeConfig(home, { url, machineId: answer.machine.id, organization, account });
+        await writeFile(tokenPath(home), token, { mode: 0o600 });
         await writeAgentConfigs({ writes: answer.write });
-        await wireRepos({ url, token, dirs: clonedDirs(await readEnvironment()) });
+        await wireRepos({ url, token, organization, dirs: clonedDirs(await readEnvironment(home)) });
         await installService();
         if (install)
-            await machine.beatOnce(ui.say);
-        return answer.machine;
+            await machine.beatOnce({ home, say: ui.say });
+        return { url, token, machine: answer.machine, organization };
     },
-    async workDir() {
-        const organization = (await readConfig())?.organization;
-        return organization === undefined ? null : setup.workDir(organization);
+    async workDir(organization) {
+        return setup.workDir(organization);
     },
     async controlPlane(override) {
-        const where = override ?? process.env.CRAFTSPACE_URL ?? (await readConfig())?.url ?? DEFAULT_URL;
+        const where = override ?? process.env.CRAFTSPACE_URL ?? (await anySeat())?.config.url ?? DEFAULT_URL;
         return where.replace(/\/$/, '');
     },
     async signIn({ url, why, install = false }) {
-        const where = url ?? (await readConfig())?.url ?? DEFAULT_URL;
+        const where = url ?? (await anySeat())?.config.url ?? DEFAULT_URL;
         if (!process.stdin.isTTY)
             throw new Error(`${why} Run: cs login --token <token>`);
         const page = `${where}/workstations`;
@@ -73,16 +91,34 @@ export const machine = {
         if (token === undefined)
             throw new Error('That line carries no key.');
         const signed = await machine.login({ token, url: where, install });
-        ui.say(`\n${ui.ok(`Signed in as ${signed.ownerName}. This machine is ${ui.name(signed.name)}.`)}`);
-        return { url: where, token, machine: signed };
+        ui.say(`\n${ui.ok(`Signed in as ${signed.machine.ownerName}. This machine is ${ui.name(signed.machine.name)}.`)}`);
+        return signed;
     },
     async status() {
-        const found = await withAuth(await signedInOrAsk(), (auth) => call({ ...auth, method: 'GET', path: '/api/machines/me', schema: MachineSchema }));
-        return { machine: found.value, url: found.auth.url };
+        const seats = await machine.seats();
+        if (seats.length === 0) {
+            const signed = await machine.signIn({ why: 'This machine is not signed in to Craftspace yet.' });
+            return [{ machine: signed.machine, url: signed.url, organization: signed.organization }];
+        }
+        const found = [];
+        for (const seat of seats) {
+            const live = await withAuth(await authOf(seat), (auth) => call({ ...auth, method: 'GET', path: '/api/machines/me', schema: MachineSchema }));
+            found.push({ machine: live.value, url: live.auth.url, organization: seat.config.organization ?? '?' });
+        }
+        return found;
     },
-    async beatOnce(say) {
-        const { url, token, organization } = await requireSignedIn();
-        const built = await readEnvironment();
+    async beatAll(say) {
+        const seats = await machine.seats();
+        if (seats.length === 0)
+            throw new Error('This machine is not signed in. Run: cs login --token <token>');
+        let busy = false;
+        for (const seat of seats)
+            busy = (await machine.beatOnce({ home: seat.home, say })) || busy;
+        return busy;
+    },
+    async beatOnce({ home, say }) {
+        const { url, token, organization } = await requireSignedIn(home);
+        const built = await readEnvironment(home);
         const answer = await call({
             url,
             token,
@@ -92,8 +128,8 @@ export const machine = {
                 cli: CLI_VERSION,
                 ...load(),
                 sessions: await readSessions(),
-                runs: drainReports(),
-                tools: await checks(),
+                runs: drainReports(home),
+                tools: await checks(home),
                 environment: built?.results ?? [],
                 templateId: built?.templateId ?? null,
                 ...(organization === undefined ? {} : { workDir: setup.workDir(organization) }),
@@ -106,10 +142,10 @@ export const machine = {
             updateWanted = answer.cli.version;
         const workDir = setup.workDir(answer.organization);
         if (answer.organization !== organization)
-            await writeConfig({ organization: answer.organization });
-        await migrate.toLatest({ home: machine.home(), workDir }).catch(() => []);
-        await writeAuthorizedKeys(answer.authorizedKeys);
-        const building = buildEnvironment({ next: answer.environment, workDir, say });
+            await writeConfig(home, { organization: answer.organization });
+        await migrate.toLatest({ home: machine.root(), workDir }).catch(() => []);
+        await writeAuthorizedKeys({ organization: answer.organization, keys: answer.authorizedKeys });
+        const building = buildEnvironment({ next: answer.environment, home, workDir, say });
         if (say === undefined)
             void building.catch(() => undefined);
         else
@@ -119,9 +155,9 @@ export const machine = {
                 continue;
             running.add(work.id);
             void runner
-                .unattended({ work, cwd: startIn(built), onProgress: report })
-                .then(report)
-                .catch((error) => report({ id: work.id, state: 'failed', output: messageOf(error) }))
+                .unattended({ work, cwd: startIn(built), onProgress: (next) => report(home, next) })
+                .then((next) => report(home, next))
+                .catch((error) => report(home, { id: work.id, state: 'failed', output: messageOf(error) }))
                 .finally(() => running.delete(work.id));
         }
         return running.size > 0 || answer.work.length > 0;
@@ -142,7 +178,7 @@ export const machine = {
                 }
             }
             try {
-                busy = await machine.beatOnce();
+                busy = await machine.beatAll();
                 failures = 0;
             }
             catch (error) {
@@ -153,7 +189,7 @@ export const machine = {
         }
     },
     async run() {
-        const first = await signedInOrAsk();
+        const first = await authOfAnySeatOrAsk();
         const { auth, value: answer } = await withAuth(first, (live) => call({ ...live, method: 'GET', path: '/api/machines', schema: MachinesResponseSchema }));
         if (answer.machines.length === 0)
             return nowhereToGo(auth);
@@ -171,23 +207,58 @@ export const machine = {
         return { text: BEATING, ok: true };
     },
     async logout() {
-        const config = await readConfig();
-        const token = await readToken();
-        if (config && token) {
-            await call({ url: config.url, token, method: 'POST', path: '/api/machines/logout', schema: z.object({}) }).catch(() => undefined);
+        for (const seat of await machine.seats()) {
+            const token = await readToken(seat.home);
+            if (token === null)
+                continue;
+            await call({
+                url: seat.config.url,
+                token,
+                method: 'POST',
+                path: '/api/machines/logout',
+                schema: z.object({}),
+            }).catch(() => undefined);
+            await removeAgentConfigs(seat.home);
+            if (seat.config.organization !== undefined) {
+                await writeAuthorizedKeys({ organization: seat.config.organization, keys: [] });
+            }
         }
-        await removeAgentConfigs();
+        await unwireRepos();
         await uninstallService();
-        await rm(machine.home(), { recursive: true, force: true });
+        await rm(machine.root(), { recursive: true, force: true });
     },
 };
-async function requireSignedIn() {
-    const config = await readConfig();
-    const token = await readToken();
+async function requireSignedIn(home) {
+    const config = await readConfig(home);
+    const token = await readToken(home);
     if (!config || !token)
         throw new Error('This machine is not signed in. Run: cs login --token <token>');
     return { url: config.url, token, ...spreadIfDefined({ organization: config.organization }) };
 }
+// A box holds one ACCOUNT and as many of that account's orgs as it likes. Two accounts would share this
+// box's one ssh key, its sessions and its ~/.claude.json, so each would be acting as the other.
+async function refuseSecondAccount({ account, organization, }) {
+    const taken = (await machine.seats()).find((seat) => seat.config.account !== undefined && seat.config.account !== account);
+    if (taken === undefined)
+        return;
+    throw new Error(`This box is already signed in as someone else, under ${taken.config.organization ?? 'another org'}. ` +
+        `One box holds one account, any number of its orgs. Run: cs logout, then sign in for ${organization}.`);
+}
+async function anySeat() {
+    return (await machine.seats())[0];
+}
+async function authOf(seat) {
+    const token = await readToken(seat.home);
+    if (token === null)
+        throw new Error('This machine is not signed in. Run: cs login --token <token>');
+    return { url: seat.config.url, token };
+}
+async function authOfAnySeatOrAsk() {
+    const seat = await anySeat();
+    if (seat === undefined)
+        return machine.signIn({ why: 'This machine is not signed in to Craftspace yet.' });
+    return authOf(seat);
+}
 async function pick(machines) {
     return select({
         message: 'Which workstation?',
@@ -242,27 +313,29 @@ function nowhereToGo({ url }) {
     ui.say('\n');
     return 1;
 }
-async function checks() {
-    if (probed !== null && Date.now() - probed.at < PROBE_EVERY_MS)
-        return probed.tools;
-    const dirs = clonedDirs(await readEnvironment());
-    const first = await probe.tools({ dirs });
+async function checks(home) {
+    const seen = probed.get(home);
+    if (seen !== undefined && Date.now() - seen.at < PROBE_EVERY_MS)
+        return seen.tools;
+    const organization = (await readConfig(home))?.organization ?? 'team';
+    const dirs = clonedDirs(await readEnvironment(home));
+    const first = await probe.tools({ dirs, organization });
     const unwired = first.some((tool) => tool.id === 'brain' && !tool.ok);
     const found = unwired && installs() && dirs.length > 0
-        ? await rewire(dirs).then(() => probe.tools({ dirs }), () => first)
+        ? await rewire(home, dirs).then(() => probe.tools({ dirs, organization }), () => first)
         : first;
-    probed = { at: Date.now(), tools: found };
+    probed.set(home, { at: Date.now(), tools: found });
     return found;
 }
-async function buildEnvironment({ next, workDir, say, }) {
-    if (building || !installs() || next.templateId === null)
+async function buildEnvironment({ next, home, workDir, say, }) {
+    if (building.has(home) || !installs() || next.templateId === null)
         return;
-    const built = await readEnvironment();
+    const built = await readEnvironment(home);
     const buildsSteps = buildIsDue(built, next.templateId);
     const clonesRepos = cloneIsDue({ built, wanted: next.repos, workDir });
     if (!buildsSteps && !clonesRepos)
         return;
-    building = true;
+    building.add(home);
     try {
         let results = built?.results ?? [];
         let repos = built?.repos ?? [];
@@ -273,12 +346,12 @@ async function buildEnvironment({ next, workDir, say, }) {
         if (clonesRepos) {
             say?.(ui.heading(`Cloning the ${next.repos.length} repos your team works in, into ${workDir}`));
             repos = await setup.cloneRepos({ repos: next.repos, workDir, say });
-            await rewire(repos.filter((repo) => repo.ok).map((repo) => repo.path));
+            await rewire(home, repos.filter((repo) => repo.ok).map((repo) => repo.path));
         }
-        await writeEnvironment({ templateId: next.templateId, results, repos, at: Date.now() });
+        await writeEnvironment(home, { templateId: next.templateId, results, repos, at: Date.now() });
     }
     finally {
-        building = false;
+        building.delete(home);
     }
 }
 function cloneIsDue({ built, wanted, workDir, }) {
@@ -305,35 +378,42 @@ function buildIsDue(built, templateId) {
         return false;
     return Date.now() - built.at > REBUILD_AFTER_MS;
 }
-async function readEnvironment() {
-    const raw = await readFile(environmentPath(), 'utf8').catch(() => null);
+async function readEnvironment(home) {
+    const raw = await readFile(environmentPath(home), 'utf8').catch(() => null);
     if (raw === null)
         return null;
     const parsed = BuiltSchema.safeParse(JSON.parse(raw));
     return parsed.success ? parsed.data : null;
 }
-async function writeEnvironment(built) {
-    await mkdir(machine.home(), { recursive: true, mode: 0o700 });
-    await writeFile(environmentPath(), JSON.stringify(built, null, 2), { mode: 0o600 });
+async function writeEnvironment(home, built) {
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    await writeFile(environmentPath(home), JSON.stringify(built, null, 2), { mode: 0o600 });
 }
 function installs() {
     return process.env.CRAFTSPACE_NO_INSTALL !== '1';
 }
-async function rewire(dirs) {
-    const { url, token } = await requireSignedIn();
-    await wireRepos({ url, token, dirs });
+async function rewire(home, dirs) {
+    const { url, token, organization } = await requireSignedIn(home);
+    await wireRepos({ url, token, organization: organization ?? 'team', dirs });
 }
 function clonedDirs(built) {
     return (built?.repos ?? []).filter((repo) => repo.ok).map((repo) => repo.path);
 }
-function report(next) {
-    reports.set(next.id, next);
+function report(home, next) {
+    const mine = reports.get(home) ?? new Map();
+    mine.set(next.id, next);
+    reports.set(home, mine);
 }
-function drainReports() {
-    const pending = [...reports.values()];
+// A run belongs to the org that queued it, so its reports go back on THAT seat's beat. Draining one shared
+// map would post org A's output to org B, which answers 404 and loses the run.
+function drainReports(home) {
+    const mine = reports.get(home);
+    if (mine === undefined)
+        return [];
+    const pending = [...mine.values()];
     for (const item of pending)
         if (item.state !== 'running')
-            reports.delete(item.id);
+            mine.delete(item.id);
     return pending;
 }
 async function call({ url, token, method, path: route, body, schema, }) {
@@ -357,13 +437,6 @@ class Unauthorized extends Error {
         super('This machine no longer has a key Craftspace accepts.');
     }
 }
-async function signedInOrAsk() {
-    const config = await readConfig();
-    const token = await readToken();
-    if (config && token)
-        return { url: config.url, token };
-    return machine.signIn({ why: 'This machine is not signed in to Craftspace yet.' });
-}
 async function withAuth(auth, work) {
     try {
         return { auth, value: await work(auth) };
@@ -387,32 +460,47 @@ export function tokenIn(line) {
     return /cst_[A-Za-z0-9_-]+/.exec(line)?.[0];
 }
 async function ensureKey() {
-    const priv = path.join(machine.home(), 'id_ed25519');
+    const priv = path.join(machine.root(), 'id_ed25519');
     const pub = `${priv}.pub`;
     const existing = await readFile(pub, 'utf8').catch(() => null);
     if (existing !== null)
         return existing.trim();
-    await mkdir(machine.home(), { recursive: true, mode: 0o700 });
+    await mkdir(machine.root(), { recursive: true, mode: 0o700 });
     await run('ssh-keygen', ['-t', 'ed25519', '-N', '', '-q', '-f', priv, '-C', `craftspace-${os.hostname()}`]);
     return (await readFile(pub, 'utf8')).trim();
 }
-async function writeConfig(next) {
-    const merged = { ...(await readConfig()), ...next };
-    await mkdir(machine.home(), { recursive: true, mode: 0o700 });
-    await writeFile(configPath(), `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
+async function writeConfig(home, next) {
+    const merged = { ...(await readConfig(home)), ...next };
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    await writeFile(configPath(home), `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
 }
-async function readConfig() {
-    const raw = await readFile(configPath(), 'utf8').catch(() => null);
+async function readConfig(home) {
+    const raw = await readFile(configPath(home), 'utf8').catch(() => null);
     if (raw === null)
         return null;
-    return ConfigSchema.parse(JSON.parse(raw));
+    const parsed = ConfigSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
 }
-async function readToken() {
-    const raw = await readFile(tokenPath(), 'utf8').catch(() => null);
+async function readToken(home) {
+    const raw = await readFile(tokenPath(home), 'utf8').catch(() => null);
     return raw === null ? null : raw.trim();
 }
+// One box, one account, one seat per org. Everything an org owns lives in its own directory under the
+// root; the box's ssh key, its sessions and the migration marks are the box's, so they stay at the root.
+async function settleLayout() {
+    const root = machine.root();
+    const config = await readConfig(root);
+    const organization = config?.organization;
+    if (config === null || organization === undefined)
+        return;
+    const home = path.join(root, organization);
+    await mkdir(home, { recursive: true, mode: 0o700 });
+    for (const name of SEAT_FILES) {
+        await rename(path.join(root, name), path.join(home, name)).catch(() => undefined);
+    }
+}
 async function readSessions() {
-    const dir = path.join(machine.home(), 'sessions');
+    const dir = path.join(machine.root(), 'sessions');
     const names = await readdir(dir).catch(() => []);
     const sessions = [];
     for (const name of names.filter((entry) => entry.endsWith('.json'))) {
@@ -425,22 +513,36 @@ async function readSessions() {
     }
     return sessions.slice(0, MAX_REPORTED_SESSIONS);
 }
-async function writeAuthorizedKeys(keys) {
+// Each org grants its own keys, so each owns its own marked block. One shared pair of markers made the
+// second org's write delete the first org's keys, which locks out whoever was relying on them.
+async function writeAuthorizedKeys({ organization, keys }) {
     const target = path.join(os.homedir(), '.ssh', 'authorized_keys');
     const current = await readFile(target, 'utf8').catch(() => '');
-    const before = current.split(KEYS_BEGIN)[0] ?? '';
-    const after = current.includes(KEYS_END) ? (current.split(KEYS_END)[1] ?? '') : '';
-    const block = keys.length === 0 ? '' : `${KEYS_BEGIN}\n${keys.join('\n')}\n${KEYS_END}\n`;
-    const next = `${trimEnd(before)}${trimEnd(before) === '' ? '' : '\n'}${block}${after.replace(/^\n/, '')}`;
+    const block = keys.length === 0 ? '' : `${keys.join('\n')}\n`;
+    const next = replaceBlock({
+        text: replaceBlock({ text: current, begin: KEYS_BEGIN, end: KEYS_END, block: '' }),
+        begin: `${KEYS_BEGIN} ${organization}`,
+        end: `${KEYS_END} ${organization}`,
+        block,
+    });
     if (next === current)
         return;
     await mkdir(path.dirname(target), { recursive: true, mode: 0o700 });
     await writeFile(target, next, { mode: 0o600 });
 }
+export function replaceBlock({ text, begin, end, block, }) {
+    const before = text.split(begin)[0] ?? '';
+    const after = text.includes(end) ? (text.split(end)[1] ?? '') : text.includes(begin) ? '' : null;
+    if (after === null && block === '')
+        return text;
+    const kept = after ?? '';
+    const wrapped = block === '' ? '' : `${begin}\n${block}${end}\n`;
+    return `${trimEnd(before)}${trimEnd(before) === '' ? '' : '\n'}${wrapped}${kept.replace(/^\n/, '')}`;
+}
 function trimEnd(text) {
     return text.replace(/\s+$/, '');
 }
-async function wireRepos({ url, token, dirs }) {
+async function wireRepos({ url, token, organization, dirs, }) {
     if (dirs.length === 0)
         return;
     await migrate.stripGlobalMcp();
@@ -449,17 +551,27 @@ async function wireRepos({ url, token, dirs }) {
         for (const dir of dirs) {
             const here = isPlainObject(projects[dir]) ? { ...projects[dir] } : {};
             const servers = isPlainObject(here.mcpServers) ? { ...here.mcpServers } : {};
-            projects[dir] = { ...here, hasTrustDialogAccepted: true, mcpServers: { ...servers, craftspace: server } };
+            delete servers.craftspace;
+            projects[dir] = {
+                ...here,
+                hasTrustDialogAccepted: true,
+                mcpServers: { ...servers, [serverNameFor(organization)]: server },
+            };
         }
     });
 }
+// A repo is only ever cloned under ONE org's work dir, so the entry could be named `craftspace` and never
+// collide. It carries the org anyway: `cs logout` has to know whose entry it is removing, and a member
+// reading ~/.claude.json should be able to tell which brain a checkout is pointed at.
+function serverNameFor(organization) {
+    return `craftspace-${organization}`;
+}
 async function unwireRepos() {
     await editClaudeConfig((projects) => {
         for (const [dir, found] of Object.entries(projects)) {
             if (!isPlainObject(found) || !isPlainObject(found.mcpServers))
                 continue;
-            const servers = { ...found.mcpServers };
-            delete servers.craftspace;
+            const servers = Object.fromEntries(Object.entries(found.mcpServers).filter(([name]) => name !== 'craftspace' && !name.startsWith('craftspace-')));
             projects[dir] = { ...found, mcpServers: servers };
         }
     });
@@ -478,7 +590,7 @@ async function editClaudeConfig(edit) {
 async function writeAgentConfigs({ writes, }) {
     if (writes.length === 0)
         return;
-    const owned = [...(await readOwned())];
+    const owned = [];
     for (const write of writes) {
         const target = expand(write.path);
         await mkdir(path.dirname(target), { recursive: true });
@@ -489,10 +601,10 @@ async function writeAgentConfigs({ writes, }) {
         await writeFile(target, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
         owned.push(target);
     }
-    await writeFile(ownedPath(), JSON.stringify({ paths: [...new Set(owned)] }, null, 2));
+    await writeFile(ownedPath(machine.root()), JSON.stringify({ paths: [...new Set(owned)] }, null, 2));
 }
-async function readOwned() {
-    const raw = await readFile(ownedPath(), 'utf8').catch(() => null);
+async function readOwned(home) {
+    const raw = await readFile(ownedPath(home), 'utf8').catch(() => null);
     if (raw === null)
         return [];
     const parsed = OwnedSchema.safeParse(JSON.parse(raw));
@@ -510,9 +622,8 @@ function mergeInto(current, incoming) {
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-async function removeAgentConfigs() {
-    await unwireRepos();
-    for (const target of await readOwned()) {
+async function removeAgentConfigs(home) {
+    for (const target of await readOwned(home)) {
         const current = await readFile(target, 'utf8').catch(() => null);
         if (current === null)
             continue;
@@ -609,17 +720,17 @@ function entryPath() {
 function expand(target) {
     return target.startsWith('~/') ? path.join(os.homedir(), target.slice(2)) : target;
 }
-function configPath() {
-    return path.join(machine.home(), 'config.json');
+function configPath(home) {
+    return path.join(home, 'config.json');
 }
-function tokenPath() {
-    return path.join(machine.home(), 'token');
+function tokenPath(home) {
+    return path.join(home, 'token');
 }
-function ownedPath() {
-    return path.join(machine.home(), 'owned.json');
+function ownedPath(home) {
+    return path.join(home, 'owned.json');
 }
-function environmentPath() {
-    return path.join(machine.home(), 'environment.json');
+function environmentPath(home) {
+    return path.join(home, 'environment.json');
 }
 function load() {
     const cores = Math.max(1, os.cpus().length);
@@ -638,7 +749,12 @@ export function nextDelayMs(failures, busy = false) {
 function messageOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
-const ConfigSchema = z.object({ url: z.string(), machineId: z.string(), organization: z.string().optional() });
+const ConfigSchema = z.object({
+    url: z.string(),
+    machineId: z.string(),
+    organization: z.string().optional(),
+    account: z.string().optional(),
+});
 const BuiltSchema = z.object({
     templateId: z.string(),
     results: z.array(WorkstationStepResultSchema),
@@ -647,6 +763,7 @@ const BuiltSchema = z.object({
 });
 const OwnedSchema = z.object({ paths: z.array(z.string()) });
 const CLAUDE_FILE = '.claude.json';
+const SEAT_FILES = ['config.json', 'token', 'environment.json', 'owned.json'];
 const SERVICE_NAME = 'craftspace';
 const LAUNCH_LABEL = 'app.craftspace.machine';
 const REQUEST_TIMEOUT_MS = 15_000;
@@ -677,7 +794,7 @@ const DEFAULT_URL = process.env.CRAFTSPACE_URL ?? 'https://craftspace.app';
 const PROBE_EVERY_MS = 300_000;
 const REBUILD_AFTER_MS = 21_600_000;
 let updateWanted = null;
-let probed = null;
-let building = false;
+const probed = new Map();
+const building = new Set();
 const reports = new Map();
 const running = new Set();

package/dist/probe.d.ts

@@ -1,6 +1,7 @@
 import type { MachineTool } from '@craftspace/shared';
 export declare const probe: {
-    tools({ dirs }: {
+    tools({ dirs, organization }: {
         dirs: string[];
+        organization: string;
     }): Promise<MachineTool[]>;
 };