@craftspace/cli 0.8.0 → 0.9.1

package/dist/machine.d.ts

@@ -6,6 +6,7 @@ export declare const machine: {
         url: string;
         install: boolean;
     }): Promise<Machine>;
+    workDir(): Promise<string | null>;
     controlPlane(override?: string): Promise<string>;
     signIn({ url, why, install }: {
         url?: string;

package/dist/machine.js

@@ -1,11 +1,13 @@
 import { execFile, spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
 import { mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { promisify } from 'node:util';
-import { CLI_VERSION, MACHINE_BEAT_BUSY_INTERVAL_MS, MACHINE_BEAT_INTERVAL_MS, MachineBeatResponseSchema, MachineLoginResponseSchema, MachineSchema, MachineRepoSchema, MachineSessionSchema, MachinesResponseSchema, WorkstationStepResultSchema, } from '@craftspace/shared';
+import { CLI_VERSION, MACHINE_BEAT_BUSY_INTERVAL_MS, MACHINE_BEAT_INTERVAL_MS, MachineBeatResponseSchema, MachineLoginResponseSchema, MachineSchema, MachineRepoSchema, MachineSessionSchema, MachinesResponseSchema, WorkstationStepResultSchema, spreadIfDefined, toSpaceSlug, } from '@craftspace/shared';
 import { confirm, input, select } from '@inquirer/prompts';
 import { z } from 'zod';
+import { migrate } from './migrate.js';
 import { probe } from './probe.js';
 import { runner } from './run.js';
 import { setup } from './setup.js';
@@ -34,14 +36,19 @@ export const machine = {
             schema: MachineLoginResponseSchema,
         });
         await mkdir(machine.home(), { recursive: true, mode: 0o700 });
-        await writeFile(configPath(), JSON.stringify({ url, machineId: answer.machine.id }, null, 2), { mode: 0o600 });
+        await writeConfig({ url, machineId: answer.machine.id, organization: toSpaceSlug(answer.organizationName) });
         await writeFile(tokenPath(), token, { mode: 0o600 });
-        await writeAgentConfigs({ url, token, writes: answer.write });
+        await writeAgentConfigs({ writes: answer.write });
+        await wireRepos({ url, token, dirs: clonedDirs(await readEnvironment()) });
         await installService();
         if (install)
             await machine.beatOnce(ui.say);
         return answer.machine;
     },
+    async workDir() {
+        const organization = (await readConfig())?.organization;
+        return organization === undefined ? null : setup.workDir(organization);
+    },
     async controlPlane(override) {
         const where = override ?? process.env.CRAFTSPACE_URL ?? (await readConfig())?.url ?? DEFAULT_URL;
         return where.replace(/\/$/, '');
@@ -74,7 +81,7 @@ export const machine = {
         return { machine: found.value, url: found.auth.url };
     },
     async beatOnce(say) {
-        const { url, token } = await requireSignedIn();
+        const { url, token, organization } = await requireSignedIn();
         const built = await readEnvironment();
         const answer = await call({
             url,
@@ -89,7 +96,7 @@ export const machine = {
                 tools: await checks(),
                 environment: built?.results ?? [],
                 templateId: built?.templateId ?? null,
-                workDir: setup.workDir(),
+                ...(organization === undefined ? {} : { workDir: setup.workDir(organization) }),
                 repos: built?.repos ?? [],
                 sshUser: os.userInfo().username,
             },
@@ -97,8 +104,12 @@ export const machine = {
         });
         if (answer.cli !== null && isNewer(answer.cli.version))
             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(answer.environment, say);
+        const building = buildEnvironment({ next: answer.environment, workDir, say });
         if (say === undefined)
             void building.catch(() => undefined);
         else
@@ -175,7 +186,7 @@ async function requireSignedIn() {
     const token = await readToken();
     if (!config || !token)
         throw new Error('This machine is not signed in. Run: cs login --token <token>');
-    return { url: config.url, token };
+    return { url: config.url, token, ...spreadIfDefined({ organization: config.organization }) };
 }
 async function pick(machines) {
     return select({
@@ -234,18 +245,21 @@ function nowhereToGo({ url }) {
 async function checks() {
     if (probed !== null && Date.now() - probed.at < PROBE_EVERY_MS)
         return probed.tools;
-    const first = await probe.tools();
+    const dirs = clonedDirs(await readEnvironment());
+    const first = await probe.tools({ dirs });
     const unwired = first.some((tool) => tool.id === 'brain' && !tool.ok);
-    const found = unwired && installs() ? await rewire().then(() => probe.tools(), () => first) : first;
+    const found = unwired && installs() && dirs.length > 0
+        ? await rewire(dirs).then(() => probe.tools({ dirs }), () => first)
+        : first;
     probed = { at: Date.now(), tools: found };
     return found;
 }
-async function buildEnvironment(next, say) {
+async function buildEnvironment({ next, workDir, say, }) {
     if (building || !installs() || next.templateId === null)
         return;
     const built = await readEnvironment();
     const buildsSteps = buildIsDue(built, next.templateId);
-    const clonesRepos = cloneIsDue(built, next.repos);
+    const clonesRepos = cloneIsDue({ built, wanted: next.repos, workDir });
     if (!buildsSteps && !clonesRepos)
         return;
     building = true;
@@ -257,9 +271,9 @@ async function buildEnvironment(next, say) {
             results = await setup.runSteps({ steps: next.steps, say });
         }
         if (clonesRepos) {
-            say?.(ui.heading(`Cloning the ${next.repos.length} repos your team works in, into ${setup.workDir()}`));
-            repos = await setup.cloneRepos({ repos: next.repos, say });
-            await acceptClaudeGates(['craftspace'], repos.filter((repo) => repo.ok).map((repo) => repo.path));
+            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 writeEnvironment({ templateId: next.templateId, results, repos, at: Date.now() });
     }
@@ -267,15 +281,20 @@ async function buildEnvironment(next, say) {
         building = false;
     }
 }
-function cloneIsDue(built, wanted) {
+function cloneIsDue({ built, wanted, workDir, }) {
     const cloned = built?.repos ?? [];
     if (wanted.length === 0 && cloned.length === 0)
         return false;
     if (wanted.length !== cloned.length)
         return true;
-    const missing = wanted.some((repo) => !cloned.some((seen) => seen.name === repo.name && seen.ref === repo.ref && seen.ok));
+    const missing = wanted.some((repo) => !cloned.some((seen) => isCloned({ seen, repo, workDir })));
     return missing || Date.now() - (built?.at ?? 0) > REBUILD_AFTER_MS;
 }
+function isCloned({ seen, repo, workDir, }) {
+    if (seen.name !== repo.name || seen.ref !== repo.ref || !seen.ok)
+        return false;
+    return path.dirname(seen.path) === workDir && existsSync(seen.path);
+}
 function startIn(built) {
     return built?.repos.find((repo) => repo.ok)?.path ?? os.homedir();
 }
@@ -300,9 +319,12 @@ async function writeEnvironment(built) {
 function installs() {
     return process.env.CRAFTSPACE_NO_INSTALL !== '1';
 }
-async function rewire() {
+async function rewire(dirs) {
     const { url, token } = await requireSignedIn();
-    await writeAgentConfigs({ url, token, writes: [] });
+    await wireRepos({ url, token, dirs });
+}
+function clonedDirs(built) {
+    return (built?.repos ?? []).filter((repo) => repo.ok).map((repo) => repo.path);
 }
 function report(next) {
     reports.set(next.id, next);
@@ -374,6 +396,11 @@ async function ensureKey() {
     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 readConfig() {
     const raw = await readFile(configPath(), 'utf8').catch(() => null);
     if (raw === null)
@@ -413,10 +440,46 @@ async function writeAuthorizedKeys(keys) {
 function trimEnd(text) {
     return text.replace(/\s+$/, '');
 }
-async function writeAgentConfigs({ url, token, writes, }) {
-    const planned = writes.length > 0 ? writes : defaultWrites({ url, token });
-    const owned = [];
-    for (const write of planned) {
+async function wireRepos({ url, token, dirs }) {
+    if (dirs.length === 0)
+        return;
+    await migrate.stripGlobalMcp();
+    const server = { type: 'http', url: `${url}/mcp`, headers: { Authorization: `Bearer ${token}` } };
+    await editClaudeConfig((projects) => {
+        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 } };
+        }
+    });
+}
+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;
+            projects[dir] = { ...found, mcpServers: servers };
+        }
+    });
+}
+async function editClaudeConfig(edit) {
+    const target = path.join(os.homedir(), CLAUDE_FILE);
+    const raw = await readFile(target, 'utf8').catch(() => null);
+    const parsed = raw === null ? {} : JSON.parse(raw);
+    const projects = isPlainObject(parsed.projects) ? { ...parsed.projects } : {};
+    const before = JSON.stringify(projects);
+    edit(projects);
+    if (JSON.stringify(projects) === before)
+        return;
+    await writeFile(target, `${JSON.stringify({ ...parsed, projects }, null, 2)}\n`, { mode: 0o600 });
+}
+async function writeAgentConfigs({ writes, }) {
+    if (writes.length === 0)
+        return;
+    const owned = [...(await readOwned())];
+    for (const write of writes) {
         const target = expand(write.path);
         await mkdir(path.dirname(target), { recursive: true });
         const current = await readFile(target, 'utf8').catch(() => null);
@@ -426,38 +489,14 @@ async function writeAgentConfigs({ url, token, writes, }) {
         await writeFile(target, `${JSON.stringify(merged, null, 2)}\n`, { mode: 0o600 });
         owned.push(target);
     }
-    await writeFile(ownedPath(), JSON.stringify({ paths: owned }, null, 2));
-    await acceptClaudeGates(serversIn(planned));
-}
-function serversIn(writes) {
-    return writes.flatMap((write) => isPlainObject(write.contents.mcpServers) ? Object.keys(write.contents.mcpServers) : []);
+    await writeFile(ownedPath(), JSON.stringify({ paths: [...new Set(owned)] }, null, 2));
 }
-async function acceptClaudeGates(servers, dirs = [os.homedir()]) {
-    const target = path.join(os.homedir(), '.claude.json');
-    const raw = await readFile(target, 'utf8').catch(() => null);
+async function readOwned() {
+    const raw = await readFile(ownedPath(), 'utf8').catch(() => null);
     if (raw === null)
-        return;
-    const parsed = JSON.parse(raw);
-    const projects = isPlainObject(parsed.projects) ? parsed.projects : {};
-    const opened = { ...projects };
-    let moved = false;
-    for (const dir of dirs) {
-        const found = opened[dir];
-        const here = isPlainObject(found) ? { ...found } : {};
-        const enabled = new Set([...asArray(here.enabledMcpjsonServers), ...servers]);
-        if (here.hasTrustDialogAccepted === true && enabled.size === asArray(here.enabledMcpjsonServers).length)
-            continue;
-        here.hasTrustDialogAccepted = true;
-        here.enabledMcpjsonServers = [...enabled];
-        opened[dir] = here;
-        moved = true;
-    }
-    if (!moved)
-        return;
-    await writeFile(target, `${JSON.stringify({ ...parsed, projects: opened }, null, 2)}\n`, { mode: 0o600 });
-}
-function asArray(value) {
-    return Array.isArray(value) ? value : [];
+        return [];
+    const parsed = OwnedSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data.paths : [];
 }
 function mergeInto(current, incoming) {
     const merged = { ...current };
@@ -471,16 +510,9 @@ function mergeInto(current, incoming) {
 function isPlainObject(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
-function defaultWrites({ url, token }) {
-    const server = { craftspace: { type: 'http', url: `${url}/mcp`, headers: { Authorization: `Bearer ${token}` } } };
-    return [{ path: '~/.mcp.json', contents: { mcpServers: server } }];
-}
 async function removeAgentConfigs() {
-    const raw = await readFile(ownedPath(), 'utf8').catch(() => null);
-    if (raw === null)
-        return;
-    const owned = OwnedSchema.parse(JSON.parse(raw));
-    for (const target of owned.paths) {
+    await unwireRepos();
+    for (const target of await readOwned()) {
         const current = await readFile(target, 'utf8').catch(() => null);
         if (current === null)
             continue;
@@ -606,7 +638,7 @@ 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() });
+const ConfigSchema = z.object({ url: z.string(), machineId: z.string(), organization: z.string().optional() });
 const BuiltSchema = z.object({
     templateId: z.string(),
     results: z.array(WorkstationStepResultSchema),
@@ -614,6 +646,7 @@ const BuiltSchema = z.object({
     at: z.number(),
 });
 const OwnedSchema = z.object({ paths: z.array(z.string()) });
+const CLAUDE_FILE = '.claude.json';
 const SERVICE_NAME = 'craftspace';
 const LAUNCH_LABEL = 'app.craftspace.machine';
 const REQUEST_TIMEOUT_MS = 15_000;

package/dist/migrate.d.ts

@@ -0,0 +1,7 @@
+export declare const migrate: {
+    stripGlobalMcp(): Promise<void>;
+    toLatest({ home, workDir }: {
+        home: string;
+        workDir: string | null;
+    }): Promise<string[]>;
+};

package/dist/migrate.js

@@ -0,0 +1,82 @@
+import { existsSync } from 'node:fs';
+import { mkdir, readFile, readdir, rename, rm, writeFile } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { z } from 'zod';
+export const migrate = {
+    async stripGlobalMcp() {
+        const target = path.join(os.homedir(), '.mcp.json');
+        const raw = await readFile(target, 'utf8').catch(() => null);
+        if (raw === null)
+            return;
+        const parsed = JSON.parse(raw);
+        const servers = parsed.mcpServers;
+        if (typeof servers !== 'object' || servers === null || !('craftspace' in servers))
+            return;
+        delete servers.craftspace;
+        const emptied = Object.keys(servers).length === 0 && Object.keys(parsed).length === 1;
+        const ours = (await readFile(`${target}.craftspace-backup`, 'utf8').catch(() => null)) === null;
+        if (emptied && ours)
+            await rm(target, { force: true });
+        else
+            await writeFile(target, `${JSON.stringify(parsed, null, 2)}\n`, { mode: 0o600 });
+    },
+    async toLatest({ home, workDir }) {
+        const done = new Set(await alreadyRan(home));
+        const ran = [];
+        for (const step of STEPS) {
+            if (done.has(step.id))
+                continue;
+            if (!(await step.run({ workDir }).catch(() => false)))
+                continue;
+            done.add(step.id);
+            ran.push(step.id);
+        }
+        if (ran.length === 0)
+            return ran;
+        await mkdir(home, { recursive: true, mode: 0o700 });
+        await writeFile(path.join(home, RAN_FILE), `${JSON.stringify({ ran: [...done] }, null, 2)}\n`, { mode: 0o600 });
+        return ran;
+    },
+};
+const STEPS = [
+    {
+        id: '0001-work-dir-under-org',
+        async run({ workDir }) {
+            if (workDir === null)
+                return false;
+            const flat = path.dirname(workDir);
+            const org = path.basename(workDir);
+            const staged = `${org}${MOVING}`;
+            if (existsSync(path.join(workDir, '.git')))
+                await rename(workDir, path.join(flat, staged));
+            const entries = await readdir(flat, { withFileTypes: true }).catch(() => []);
+            const moving = entries.filter((entry) => entry.isDirectory() && path.join(flat, entry.name) !== workDir);
+            if (moving.length === 0)
+                return true;
+            await mkdir(workDir, { recursive: true });
+            for (const entry of moving) {
+                const to = path.join(workDir, entry.name === staged ? org : entry.name);
+                await rename(path.join(flat, entry.name), to).catch(() => undefined);
+            }
+            return true;
+        },
+    },
+    {
+        id: '0002-mcp-out-of-home',
+        async run() {
+            await migrate.stripGlobalMcp();
+            return true;
+        },
+    },
+];
+async function alreadyRan(home) {
+    const raw = await readFile(path.join(home, RAN_FILE), 'utf8').catch(() => null);
+    if (raw === null)
+        return [];
+    const parsed = RanSchema.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data.ran : [];
+}
+const RanSchema = z.object({ ran: z.array(z.string()) });
+const RAN_FILE = 'migrations.json';
+const MOVING = '.craftspace-moving';

package/dist/probe.d.ts

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

package/dist/probe.js

@@ -3,22 +3,30 @@ import { readFile } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 export const probe = {
-    async tools({ mcpPath = path.join(os.homedir(), '.mcp.json') } = {}) {
-        return Promise.all([brainWired(mcpPath), sshListening()]);
+    async tools({ dirs }) {
+        return Promise.all([brainWired(dirs), sshListening()]);
     },
 };
-async function brainWired(mcpPath) {
-    const raw = await readFile(mcpPath, 'utf8').catch(() => null);
+async function brainWired(dirs) {
+    if (dirs.length === 0) {
+        return { id: 'brain', ok: false, detail: 'no repos cloned here yet, so there is nothing to wire it into' };
+    }
+    const projects = await claudeProjects();
+    const unwired = dirs.filter((dir) => !('craftspace' in mcpServersIn(projects[dir])));
+    return unwired.length === 0
+        ? { id: 'brain', ok: true, detail: `wired into ${dirs.length} repo${dirs.length === 1 ? '' : 's'}` }
+        : { id: 'brain', ok: false, detail: `not wired into ${unwired.map(short).join(', ')}`.slice(0, DETAIL_MAX) };
+}
+async function claudeProjects() {
+    const raw = await readFile(path.join(os.homedir(), '.claude.json'), 'utf8').catch(() => null);
     if (raw === null)
-        return { id: 'brain', ok: false, detail: `no ${short(mcpPath)} on this machine` };
+        return {};
     const parsed = JSON.parse(raw);
-    const servers = parsed?.mcpServers;
-    const wired = servers !== undefined && servers !== null && 'craftspace' in servers;
-    return {
-        id: 'brain',
-        ok: wired,
-        detail: wired ? short(mcpPath) : `${short(mcpPath)} has no craftspace entry`,
-    };
+    return parsed.projects ?? {};
+}
+function mcpServersIn(project) {
+    const servers = project?.mcpServers;
+    return servers ?? {};
 }
 function sshListening() {
     return new Promise((resolve) => {
@@ -37,3 +45,4 @@ function short(target) {
     return target.startsWith(os.homedir()) ? `~${target.slice(os.homedir().length)}` : target;
 }
 const SSH_PROBE_TIMEOUT_MS = 1_500;
+const DETAIL_MAX = 200;

package/dist/setup.d.ts

@@ -1,9 +1,11 @@
 import { type MachineRepo, type WorkstationRepo, type WorkstationStep, type WorkstationStepResult } from '@craftspace/shared';
 export declare const setup: {
     widenPath(): void;
-    workDir(): string;
-    cloneRepos({ repos, say, }: {
+    workDir(organization: string): string;
+    workRoot(): string;
+    cloneRepos({ repos, workDir, say, }: {
         repos: WorkstationRepo[];
+        workDir: string;
         say?: (line: string) => void;
     }): Promise<MachineRepo[]>;
     runSteps({ steps, say, }: {

package/dist/setup.js

@@ -2,7 +2,7 @@ import { execFile } from 'node:child_process';
 import { mkdir } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
-import { WORKSTATION_STEP_DETAIL_MAX_CHARS, } from '@craftspace/shared';
+import { WORKSTATION_STEP_DETAIL_MAX_CHARS, toSpaceSlug, } from '@craftspace/shared';
 import { ui } from './ui.js';
 export const setup = {
     widenPath() {
@@ -11,17 +11,20 @@ export const setup = {
         if (missing.length > 0)
             process.env.PATH = [...current, ...missing].join(path.delimiter);
     },
-    workDir() {
+    workDir(organization) {
+        return path.join(setup.workRoot(), toSpaceSlug(organization) || FALLBACK_ORG);
+    },
+    workRoot() {
         return path.join(os.homedir(), WORK_DIR_NAME);
     },
-    async cloneRepos({ repos, say, }) {
+    async cloneRepos({ repos, workDir, say, }) {
         if (repos.length === 0)
             return [];
-        await mkdir(setup.workDir(), { recursive: true });
+        await mkdir(workDir, { recursive: true });
         const cloned = [];
         for (const [index, repo] of repos.entries()) {
             say?.(ui.progress({ name: repo.name, done: index, total: repos.length }));
-            const at = path.join(setup.workDir(), repo.name.split('/').pop() ?? repo.name);
+            const at = path.join(workDir, repo.name.split('/').pop() ?? repo.name);
             const outcome = await checkout(repo, at);
             cloned.push({ name: repo.name, ref: repo.ref, path: at, ...outcome });
             say?.(`${ui.clear()}${outcome.ok ? ui.ok(`${repo.name} · ${outcome.detail}`) : ui.bad(repo.name, outcome.detail)}`);
@@ -112,6 +115,7 @@ function toolDirs() {
     ];
 }
 const WORK_DIR_NAME = 'craftspace';
+const FALLBACK_ORG = 'team';
 const CLONE_DEPTH = 20;
 const CLONE_TIMEOUT_MS = 900_000;
 const STEP_TIMEOUT_MS = 600_000;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@craftspace/cli",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "type": "module",
   "description": "Sign a Mac or Linux machine into Craftspace and keep its agent setup in step.",
   "license": "MIT",
   "homepage": "https://craftspace.app",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/abuaboud/gus.git",
+    "url": "git+https://github.com/craftspacehq/craftspace.git",
     "directory": "packages/app/cli"
   },
   "engines": {