@koda-sl/baker-cli 0.525.0 → 0.527.0

package/dist/organization-A4NFWWWI.js

@@ -0,0 +1,949 @@
+import {
+  failApi,
+  failValidation
+} from "./chunk-J4ASA24X.js";
+import {
+  setupLinkMcpSlotSchema
+} from "./chunk-HVJJEQDQ.js";
+import "./chunk-QV6AST5T.js";
+import "./chunk-WCU362Z6.js";
+import "./chunk-GIWHHCD6.js";
+import "./chunk-SOPVIIUW.js";
+import "./chunk-G4FG5EQO.js";
+import "./chunk-NSBNIPIW.js";
+import "./chunk-46YLDIQG.js";
+import {
+  ApiError,
+  apiGet,
+  apiPost
+} from "./chunk-B4UVJCJ4.js";
+import "./chunk-AFQF6ISC.js";
+import {
+  clearTargetCompany,
+  optionalChatId,
+  optionalTargetCompany,
+  requireChatId,
+  setTargetCompany
+} from "./chunk-52IYZCRS.js";
+import {
+  registerSchema,
+  writeJson
+} from "./chunk-FSGJSREN.js";
+import "./chunk-YQSBHWOI.js";
+
+// src/commands/organization/index.ts
+import { defineCommand as defineCommand3 } from "citty";
+
+// src/commands/organization/pull.ts
+import { execFile } from "child_process";
+import {
+  chmodSync,
+  existsSync as existsSync2,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync as readFileSync2,
+  renameSync,
+  rmSync,
+  writeFileSync
+} from "fs";
+import { homedir, tmpdir } from "os";
+import { basename, join as join2, resolve } from "path";
+import { promisify } from "util";
+import { defineCommand } from "citty";
+
+// src/commands/organization/workspaces.ts
+import { cpSync, existsSync, lstatSync, readdirSync, readFileSync } from "fs";
+import { join, relative } from "path";
+var COMPANY_SURFACES = [
+  "COMPANY.md",
+  "src/content",
+  "src/collections",
+  "src/pages",
+  "src/components",
+  "src/brand",
+  "src/documents",
+  "src/creatives",
+  "src/lib/flow-engine/flows",
+  ".claude/agents",
+  "__tooling__/checks/extensions",
+  "reports/server",
+  "reports/public"
+];
+var SURFACE_GUIDE = [
+  ["COMPANY.md", "who the company is: offer, audience, positioning"],
+  ["src/content/<collection>/", "Knowledge \u2014 one folder per collection, one file per entry"],
+  [
+    "src/pages/<landing>/",
+    "landing pages \u2014 `_definition.md` says what each is for; `index.astro` and `_components/` are the page"
+  ],
+  ["src/lib/flow-engine/flows/<form>/_data.json", "Forms \u2014 steps, questions, where each submission goes"],
+  ["src/brand/", "brand \u2014 `BRAND.md` guidelines, `tokens.json` colours and fonts, logos"],
+  ["src/documents/, src/creatives/", "documents and creatives \u2014 `_definition.md` each"],
+  [".claude/agents/", "the company's own custom agents"],
+  ["__tooling__/checks/extensions/", "the company's own rules: checks its work must pass"],
+  ["reports/", "the company's own Reports"]
+];
+var VERSION_FILE = ".baker-workspace.json";
+function listFiles(root) {
+  if (!existsSync(root)) return [];
+  const files = [];
+  const walk = (dir) => {
+    for (const entry of readdirSync(dir)) {
+      const path = join(dir, entry);
+      const entryStat = lstatSync(path);
+      if (entryStat.isDirectory()) walk(path);
+      else if (!entryStat.isSymbolicLink()) files.push(relative(root, path).split("\\").join("/"));
+    }
+  };
+  walk(root);
+  return files.sort();
+}
+function copyCompanySurfaces(from, to) {
+  const notALink = (source) => !lstatSync(source).isSymbolicLink();
+  for (const surface of COMPANY_SURFACES) {
+    const source = join(from, surface);
+    if (existsSync(source)) cpSync(source, join(to, surface), { recursive: true, filter: notALink });
+  }
+}
+function slug(name) {
+  const base = name.normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+  return base || "company";
+}
+function folderNames(companies2) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const company of companies2) counts.set(slug(company.name), (counts.get(slug(company.name)) ?? 0) + 1);
+  return Object.fromEntries(
+    companies2.map((company) => {
+      const base = slug(company.name);
+      return [company.id, (counts.get(base) ?? 0) > 1 ? `${base}-${company.id.slice(-6)}` : base];
+    })
+  );
+}
+function pulledCompanyId(folder) {
+  try {
+    const recorded = JSON.parse(readFileSync(join(folder, VERSION_FILE), "utf8"));
+    return typeof recorded.companyId === "string" ? recorded.companyId : null;
+  } catch {
+    return null;
+  }
+}
+function staleFolders(dir, folders) {
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir).filter((name) => lstatSync(join(dir, name)).isDirectory()).filter((name) => {
+    const companyId = pulledCompanyId(join(dir, name));
+    return companyId !== null && folders[companyId] !== name;
+  }).sort();
+}
+
+// src/commands/organization/pull.ts
+var run = promisify(execFile);
+registerSchema({
+  command: "organization.pull",
+  description: "Download what each company made \u2014 knowledge, landing pages, Forms, brand, documents, custom agents and checks, Reports \u2014 as published, into one read-only folder per company (default ~/companies), with an INDEX.md to start from. Then read and search them like any files. Add --company <id> for one company. Only what is published: a Session's unpublished work is `baker chats diff <id> --company <id>`.",
+  args: {
+    dir: { type: "string", description: "Where to put the companies' folders (default: ~/companies)", required: false },
+    force: { type: "boolean", description: "Download again even when nothing was published since", required: false }
+  }
+});
+function readVersion(folder) {
+  try {
+    return JSON.parse(readFileSync2(join2(folder, VERSION_FILE), "utf8")).version ?? null;
+  } catch {
+    return null;
+  }
+}
+async function unpack(url, target) {
+  const scratch = mkdtempSync(join2(tmpdir(), "baker-workspace-"));
+  try {
+    const response = await fetch(url, { signal: AbortSignal.timeout(12e4) });
+    if (!response.ok) throw new Error(`download failed (${response.status})`);
+    const archive = join2(scratch, "workspace.tar.gz");
+    writeFileSync(archive, Buffer.from(await response.arrayBuffer()));
+    const unpacked = join2(scratch, "unpacked");
+    mkdirSync(unpacked);
+    await run("tar", ["-xzf", archive, "-C", unpacked, "--strip-components=1"]);
+    const staged = `${target}.partial`;
+    rmSync(staged, { recursive: true, force: true });
+    copyCompanySurfaces(unpacked, staged);
+    const files = listFiles(staged);
+    for (const file of files) chmodSync(join2(staged, file), 292);
+    rmSync(target, { recursive: true, force: true });
+    renameSync(staged, target);
+    return files.length;
+  } finally {
+    rmSync(scratch, { recursive: true, force: true });
+  }
+}
+async function pullOne(company, target, force) {
+  const entry = { id: company.id, name: company.name, folder: basename(target), status: "failed" };
+  try {
+    setTargetCompany(company.id);
+    const workspace = (await apiPost("/api/organization/workspace", {})).data;
+    if (!workspace) return { ...entry, status: "no_workspace" };
+    entry.publishedAt = workspace.publishedAt;
+    if (!force && existsSync2(target) && readVersion(target) === workspace.version) {
+      return { ...entry, status: "unchanged", files: listFiles(target).length - 1 };
+    }
+    const files = await unpack(workspace.url, target);
+    writeFileSync(
+      join2(target, VERSION_FILE),
+      `${JSON.stringify({ companyId: company.id, name: company.name, version: workspace.version, publishedAt: workspace.publishedAt }, null, 2)}
+`
+    );
+    return { ...entry, status: "updated", files };
+  } catch (err) {
+    return { ...entry, error: err instanceof Error ? err.message : String(err) };
+  }
+}
+function indexMarkdown(dir, companies2, pulled) {
+  const byId = new Map(companies2.map((company) => [company.id, company]));
+  const rows = pulled.map((entry) => {
+    const platforms = byId.get(entry.id)?.platforms.map((platform) => platform.label).join(", ") || "none";
+    const where = entry.status === "no_workspace" ? "no workspace yet" : `${entry.folder}/`;
+    return `| ${entry.name} | \`${entry.id}\` | ${where} | ${entry.publishedAt ?? "\u2014"} | ${platforms} |`;
+  });
+  return [
+    "# Companies of this organization",
+    "",
+    `Each folder holds what one company made, as published. Read-only: a change to a company is made in that company's own chat. Refresh with \`baker organization pull\`.`,
+    "",
+    "| Company | Id (for --company) | Folder | Published | Connected |",
+    "|---|---|---|---|---|",
+    ...rows,
+    "",
+    "## Where things are, in every company's folder",
+    "",
+    ...SURFACE_GUIDE.map(([path, what]) => `- \`${path}\` \u2014 ${what}`),
+    "",
+    `Search every company at once: \`grep -rn "<term>" ${dir}/*/src/content\`.`,
+    ""
+  ].join("\n");
+}
+var pullCommand = defineCommand({
+  meta: {
+    name: "pull",
+    description: `Download what each company made, as published, into one read-only folder per company.
+
+Knowledge, landing pages, Forms, brand, documents, custom agents and checks, Reports. Then read and search them like any files; start with INDEX.md.
+
+Examples:
+  baker organization pull
+  baker organization pull --company <id>
+  grep -rn "price" ~/companies/*/src/content`
+  },
+  args: {
+    dir: { type: "string", description: "Where to put the companies' folders (default: ~/companies)", required: false },
+    force: { type: "boolean", description: "Download again even when nothing was published since", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      const dir = resolve(args.dir ?? join2(homedir(), "companies"));
+      const only = optionalTargetCompany();
+      clearTargetCompany();
+      const listed = (await apiGet("/api/organization/companies")).data;
+      const companies2 = only ? listed.filter((company) => company.id === only) : listed;
+      if (only && companies2.length === 0) {
+        throw new ApiError(
+          "NOT_FOUND",
+          "No company of this organization has that id. Run `baker organization companies` for the ones you can read."
+        );
+      }
+      const folders = folderNames(listed);
+      mkdirSync(dir, { recursive: true });
+      for (const stale of staleFolders(dir, folders)) rmSync(join2(dir, stale), { recursive: true, force: true });
+      const pulled = [];
+      for (const company of companies2) {
+        pulled.push(await pullOne(company, join2(dir, folders[company.id] ?? company.id), args.force === true));
+      }
+      clearTargetCompany();
+      if (!only) writeFileSync(join2(dir, "INDEX.md"), indexMarkdown(dir, listed, pulled));
+      const failed = pulled.filter((entry) => entry.status === "failed");
+      writeJson({
+        ok: true,
+        data: { dir, companies: pulled },
+        meta: { count: pulled.length },
+        hints: [
+          `Start with ${join2(dir, "INDEX.md")}; each company's folder has the same layout.`,
+          ...failed.length > 0 ? [
+            `Not downloaded: ${failed.map((entry) => entry.name).join(", ")}. Say so in the Report; run this again to retry.`
+          ] : []
+        ]
+      });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+
+// src/commands/organization/setup.ts
+import { mkdirSync as mkdirSync2, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
+import { dirname, join as join3 } from "path";
+
+// ../api/src/organizationSetup.ts
+import { z } from "zod";
+var nameListSchema = z.array(z.string().trim().min(1)).max(50);
+var setupKindSchema = z.enum(["agencyClient", "direct", "agency"]);
+var setupTargetFields = {
+  companyId: z.string().min(1).optional(),
+  agencyId: z.string().min(1).optional()
+};
+function namesOneTarget(target) {
+  return target.companyId === void 0 !== (target.agencyId === void 0);
+}
+var ONE_TARGET = { message: "Name the company with --company <id> or the agency with --agency <id>, not both." };
+var clientSetupQuestionSchema = z.object({
+  /** An existing question's id (from `show`), to reword or answer it; absent for a new one. */
+  id: z.string().min(1).optional(),
+  question: z.string().trim().min(1).max(500),
+  /** Why it matters to the setup, in a sentence. */
+  why: z.string().trim().min(1).max(500),
+  /** The step whose chat the answer is for; absent when it is about the company as a whole. */
+  step: z.string().trim().min(1).optional(),
+  /** The answer, when the conversations already give it. The company's people can still change it. */
+  answer: z.string().trim().min(1).max(5e3).optional()
+});
+var clientSetupBriefSchema = z.object({
+  step: z.string().trim().min(1),
+  note: z.string().trim().min(1).max(2e4)
+});
+var clientSetupTeamSchema = z.object({
+  /** Every step to the kickoff, in date order. */
+  timeline: z.array(z.record(z.string(), z.unknown())).max(30).nullable().default(null),
+  /** Show or hide the timeline on the client's setup link. */
+  timelineShown: z.boolean().nullable().default(null),
+  /** The whole contract: plan, setup fee, agreement and its clauses, whether the client sees them. */
+  contract: z.record(z.string(), z.unknown()).nullable().default(null),
+  /** The client's legal and billing identity, each field a string or null to leave it. */
+  companyDetails: z.record(z.string(), z.string().nullable()).nullable().default(null),
+  welcomeEmail: z.object({ subject: z.string().trim().min(1).max(1e3), body: z.string().trim().min(1).max(2e4) }).nullable().default(null)
+});
+var CLIENT_SETUP_USES = ["creatives", "campaigns", "landings", "experiments", "reporting"];
+var clientSetupUseSchema = z.enum(CLIENT_SETUP_USES);
+var clientSetupScopeSchema = z.object({
+  /** The brands, offers or verticals, countries and audiences the team runs for it. */
+  covers: z.string().trim().min(1).max(1500),
+  /** What the client uses Baker for now, from what the team knows: required for a company's setup. */
+  uses: z.array(clientSetupUseSchema).max(CLIENT_SETUP_USES.length).optional(),
+  /** What the company does that this account leaves out, when it does more. */
+  leavesOut: z.string().trim().min(1).max(1500).optional(),
+  /** What the team does for it and how much, as agreed: the ads on which platforms, landings, creatives a month, how often to iterate. */
+  services: z.string().trim().min(1).max(1500).optional(),
+  /** No source settles it: the setup covers the whole company until someone says otherwise, and the preview says so. */
+  assumed: z.boolean().default(false)
+});
+var clientSetupToolLandingsSchema = z.enum([
+  /** A tag from Baker's catalog: `tags`. */
+  "catalogTag",
+  /** The client's Tag Manager container already loads it, and the landings load the container. */
+  "tagManager",
+  /** Its snippet, on the landings as custom code: the `code` tag. */
+  "customCode",
+  /** Already on the landings. */
+  "alreadyThere",
+  /** It does not load on a page. */
+  "notNeeded"
+]);
+var clientSetupToolAccessSchema = z.enum([
+  /** A connection or key Baker has: `connect`, `keys`. */
+  "connection",
+  /** The vendor's own MCP server: `mcp`. */
+  "mcp",
+  /** A managed app from the catalog: `apps`. */
+  "app",
+  /** Another route: its own integration with a platform Baker connects, a sheet, an automation app, a webhook. */
+  "workaround",
+  /** Already connected. */
+  "alreadyConnected",
+  /** Nothing reaches it after every route was tried. */
+  "notInBaker",
+  /** Baker never needs its data. */
+  "notNeeded"
+]);
+var clientSetupToolSchema = z.object({
+  /** Its product name: "Shopify", "Klaviyo", "Taboola". */
+  name: z.string().trim().min(1).max(100),
+  /** Its website, for its logo: "shopify.com", or the domain `inspect` named. */
+  domain: z.string().trim().min(1).max(200).optional(),
+  /** What the client uses it for: "their shop and checkout", "a pixel for a niche ad network". */
+  use: z.string().trim().min(1).max(300),
+  landings: clientSetupToolLandingsSchema,
+  access: clientSetupToolAccessSchema,
+  /** How, or what is missing: "its pixel through their Tag Manager; orders read through its MCP server". */
+  note: z.string().trim().min(1).max(1e3).optional(),
+  /** Every route checked to reach it, and what each found: "app catalog: none". Required when `access` is `notInBaker`. */
+  tried: z.array(z.string().trim().min(1).max(300)).max(10).optional()
+});
+var clientSetupSchema = z.object({
+  /** What was understood about the company and why this setup, in a few lines for the reviewer. */
+  summary: z.string().trim().min(1).max(4e3),
+  /** Where it was learned: "Gmail: 14 emails with acme.com", "Kickoff call, 3 March (Fireflies)". */
+  sources: z.array(z.string().trim().min(1).max(300)).max(30).default([]),
+  /** Steps done in Baker: `competitors`, `images`, `form`, `tracking`, `landing`, `domain`, … */
+  steps: nameListSchema.default([]),
+  /** Accounts to connect by signing in: `google-ads`, `meta`, `google-analytics`, `hubspot`, … */
+  connect: nameListSchema.default([]),
+  /** Tracking tags to add: `meta`, `googleAds`, `linkedinInsightTag`, `hotjar`, … */
+  tags: nameListSchema.default([]),
+  /** Accounts connected by pasting a key: `chatgpt-ads`. */
+  keys: nameListSchema.default([]),
+  /** Apps from the app catalog, by slug (`baker mcp catalog <search>`). */
+  apps: nameListSchema.default([]),
+  /** A vendor's own MCP server the client connects on its setup link, when Baker has no connection or app for the tool: `{ name, url }`. */
+  mcp: z.array(setupLinkMcpSlotSchema).max(10).default([]),
+  questions: z.array(clientSetupQuestionSchema).max(20).default([]),
+  /** Existing questions (by id) to take off the setup. */
+  removeQuestions: z.array(z.string().min(1)).max(20).default([]),
+  briefs: z.array(clientSetupBriefSchema).max(20).default([]),
+  /** What the account covers: required for a company's setup, never on an agency's onboarding. */
+  scope: clientSetupScopeSchema.optional(),
+  /** Every tool the client uses and how the setup covers it, for the person reviewing; the client never sees it. */
+  tooling: z.array(clientSetupToolSchema).max(60).default([]),
+  /** Baker's own team only: the timeline, contract, company details and welcome email. */
+  team: clientSetupTeamSchema.optional()
+});
+var clientSetupStepSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  /** On the company's plan right now. */
+  planned: z.boolean(),
+  /** Done in a chat with a brief, rather than a sign-in or a setting. */
+  briefed: z.boolean()
+});
+var clientSetupShowResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    /** The company, or the agency being onboarded. */
+    company: z.object({ id: z.string(), name: z.string(), website: z.string().nullable() }),
+    kind: setupKindSchema,
+    /**
+     * What this chat stages for it: the company's plan (with its questions and
+     * briefs), and our team's part — timeline, contract, company details,
+     * welcome email — under `team` (`baker organization setup team` first),
+     * in Baker's own team for a superadmin alone.
+     */
+    parts: z.object({ plan: z.boolean(), team: z.boolean() }),
+    /** Whether the person in this chat may stage a setup: an admin of the organization. */
+    canStage: z.boolean(),
+    plan: z.object({
+      steps: z.array(z.string()),
+      connect: z.array(z.string()),
+      tags: z.array(z.string()),
+      keys: z.array(z.string()),
+      apps: z.array(z.string()),
+      mcp: z.array(setupLinkMcpSlotSchema)
+    }),
+    /** Every step a plan can name, and whether this company's plan has it. */
+    catalog: z.array(clientSetupStepSchema),
+    /** Platforms the company already connected: never ask for them again. */
+    connected: z.array(z.string()),
+    /** Everything else it already has — tags with their ids, apps, Forms, landings, competitors followed, steps under way. */
+    alreadyHas: z.array(z.string()),
+    /** How to find this client in the team's tools: its email domains, the names it goes by, and notes the admins saved. */
+    recognisedBy: z.object({
+      saved: z.boolean(),
+      emailDomains: z.array(z.string()),
+      names: z.array(z.string()),
+      notes: z.string()
+    }),
+    questions: z.array(
+      z.object({
+        id: z.string(),
+        question: z.string(),
+        why: z.string(),
+        step: z.string().nullable(),
+        answer: z.string().nullable(),
+        answeredBy: z.string().nullable()
+      })
+    ),
+    briefs: z.array(z.object({ step: z.string(), note: z.string() })),
+    /** Its setup link's progress, when it has one. */
+    link: z.object({ completed: z.number(), total: z.number() }).nullable(),
+    /** What this chat staged for the company, if anything. */
+    staged: clientSetupSchema.nullable()
+  }),
+  hints: z.array(z.string()).optional()
+});
+var clientSetupSiteRequestSchema = z.object({
+  kind: z.enum(["pages", "inspect"]),
+  url: z.string().trim().min(1),
+  /** `pages` only: keep pages whose address has these words, e.g. "pricing". */
+  search: z.string().trim().min(1).optional()
+});
+var clientSetupSiteResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.record(z.string(), z.unknown())
+});
+var clientSetupStageRequestSchema = z.object({ chatId: z.string().min(1), ...setupTargetFields, setup: clientSetupSchema }).refine(namesOneTarget, ONE_TARGET);
+var clientSetupStageResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    company: z.object({ id: z.string(), name: z.string() }),
+    kind: setupKindSchema,
+    /** What publishing would change, in the dashboard's words. */
+    adds: z.array(z.string()),
+    removes: z.array(z.string()),
+    questions: z.object({ asked: z.number(), answered: z.number(), removed: z.number() }),
+    briefs: z.number(),
+    /** Our team's parts staged too, in Baker's own workspace: "timeline", "contract", "company details", "welcome email". */
+    team: z.array(z.string()).optional()
+  }),
+  hints: z.array(z.string()).optional()
+});
+var clientSetupUnstageRequestSchema = z.object({ chatId: z.string().min(1), ...setupTargetFields }).refine(namesOneTarget, ONE_TARGET);
+var clientSetupUnstageResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({ removed: z.boolean() })
+});
+var clientSetupClientsResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    /** Baker's own team, for a superadmin: every client that signs with Baker is listed, whatever its organization. */
+    everyClient: z.boolean(),
+    companies: z.array(
+      z.object({
+        id: z.string(),
+        name: z.string(),
+        website: z.string().nullable(),
+        organization: z.string(),
+        kind: setupKindSchema,
+        /** It signs with Baker: our team's part of its setup (`team`) may be staged. */
+        signsWithBaker: z.boolean()
+      })
+    ),
+    /** Baker's own team, for a superadmin: the agencies to onboard (`--agency <id>`), our team's part alone. */
+    agencies: z.array(z.object({ id: z.string(), name: z.string() })).default([]),
+    /** How many more match, at least: narrow the search. */
+    more: z.number()
+  })
+});
+var clientSetupTeamResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    company: z.object({ id: z.string(), name: z.string() }),
+    kind: setupKindSchema,
+    /** How to stage our team's part, the planner's rules for it, and each part as it stands, as Markdown. */
+    guide: z.string()
+  })
+});
+var clientSetupAttioFileSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  contentType: z.string().nullable(),
+  size: z.number().nullable(),
+  date: z.string()
+});
+var clientSetupAttioResponseSchema = z.object({
+  ok: z.literal(true),
+  data: z.object({
+    company: z.object({ id: z.string(), name: z.string() }),
+    /** Whether the company is linked to its Attio record; nothing else is read when it is not. */
+    linked: z.boolean(),
+    read: z.object({ calls: z.number(), notes: z.number(), emails: z.number(), files: z.number() }).optional(),
+    unreadable: z.array(z.string()).optional(),
+    /** Every call with its transcript, note and logged email, newest first, as Markdown. */
+    history: z.string().optional(),
+    files: z.array(clientSetupAttioFileSchema).optional(),
+    file: z.object({ id: z.string(), text: z.string().optional(), error: z.string().optional() }).optional()
+  })
+});
+
+// src/commands/organization/setup.ts
+import { defineCommand as defineCommand2 } from "citty";
+var DOC = "__tooling__/docs/tools/baker/organization.md";
+var AGENCY_ARG = {
+  type: "string",
+  description: "An agency to onboard instead of a company (`baker organization setup clients` lists them)",
+  required: false
+};
+registerSchema({
+  command: "organization.setup.show",
+  description: "Start here before preparing a setup: what kind it is (`kind`: agencyClient, direct or agency) and what it holds (`parts`: the company's plan, our team's part), the company's setup as it stands (plan steps, platforms to connect, tags, questions with their ids and answers, step briefs), every step a plan can name, the platforms it already connected, its setup link's progress, whether the person in this chat may stage a setup (only an organization admin), and what this chat already staged. Example: baker organization setup show --company <id>; an agency to onboard: baker organization setup show --agency <id>.",
+  args: { agency: AGENCY_ARG }
+});
+registerSchema({
+  command: "organization.setup.stage",
+  description: "Stage a whole setup on this chat \u2014 plan steps, platforms to connect, tags, questions (with the answers the conversations already give) and a brief per step \u2014 from a JSON file. Replaces what this chat staged for it; applied only when the person publishes, which also gives them the setup link. Only an admin of the organization. Example: baker organization setup stage --company <id> --file setup.json. File shape: { summary, sources[], steps[], connect[], tags[], keys[], apps[], questions[{id?, question, why, step?, answer?}], removeQuestions[], briefs[{step, note}], team? }. `team` is Baker's own team's part \u2014 { timeline, timelineShown, contract, companyDetails, welcomeEmail }, shapes in `baker organization setup team`. An agency's onboarding (--agency <id>) is { summary, sources[], team } and nothing else.",
+  args: {
+    file: { type: "string", description: "The setup as JSON (shape in the description)", required: true },
+    agency: AGENCY_ARG
+  }
+});
+registerSchema({
+  command: "organization.setup.clients",
+  description: "The companies this chat may prepare a setup for, when `baker organization companies` does not list the one asked for: in Baker's own team, for a superadmin, every client that signs with Baker, whatever its organization, and every agency to onboard (`agencies`, named with --agency). Example: baker organization setup clients --search acme.",
+  args: {
+    search: { type: "string", description: "Keep companies whose name or website has these words", required: false }
+  }
+});
+registerSchema({
+  command: "organization.setup.team",
+  description: "Baker's own team only, when `show` answers parts.team: true \u2014 our team's part of a setup as it stands (timeline to the kickoff, contract with Stripe's plans and coupons, company details, welcome email), the shapes to stage it under `team`, and the setup planner's rules for each (an agency's own, with --agency). Example: baker organization setup team --company <id>; baker organization setup team --agency <id>.",
+  args: { agency: AGENCY_ARG }
+});
+registerSchema({
+  command: "organization.setup.attio",
+  description: "Baker's own team only: what Baker's CRM (Attio) holds on a client that signs with Baker, or an agency to onboard \u2014 every call with its transcript, notes, logged emails \u2014 saved to a file whose path it prints, with the record's files; `--file-id` reads one file (a proposal, a deck) as text. Read it first: it is where our team's deal, offer and kickoff come from. Example: baker organization setup attio --company <id>; baker organization setup attio --agency <id>.",
+  args: {
+    "file-id": { type: "string", description: "One of the record's files, to read as text", required: false },
+    agency: AGENCY_ARG
+  }
+});
+registerSchema({
+  command: "organization.setup.pages",
+  description: "A client's website pages, from its sitemap (or what search engines know), to pick the few worth reading for its setup: each offer, pricing, contact, quote and demo page. Example: baker organization setup pages --url https://acme.com --search pricing. Read a page with `baker research fetch <url>`.",
+  args: {
+    url: { type: "string", description: "The client's website", required: true },
+    search: { type: "string", description: "Keep pages whose address has these words", required: false }
+  }
+});
+registerSchema({
+  command: "organization.setup.inspect",
+  description: "Visit a client's page as a visitor would, in a real browser that accepts its cookie banner: which tags fire and whether the page or a Tag Manager container loads each, the containers' tags, how it asks for consent (the tool, who loads it, Google Consent Mode), every form with its fields, the chat, booking and call-tracking tools, the company's other addresses (where its landings already live), what the site is built on (Shopify, WordPress, Webflow\u2026), and the outside services it talks to that no tag names (a niche ad network, an affiliate or email tool). Slow and paid: the home page, each page with a form, and any landing they run \u2014 three visits at most. Example: baker organization setup inspect --url https://acme.com.",
+  args: { url: { type: "string", description: "The page to visit", required: true } }
+});
+registerSchema({
+  command: "organization.setup.unstage",
+  description: "Take back the setup this chat staged for a company, or an agency's onboarding. Example: baker organization setup unstage --company <id>.",
+  args: { agency: AGENCY_ARG }
+});
+function setupTarget(named) {
+  if (named.company && named.agency) {
+    return { ok: false, error: "Name the company with --company or the agency with --agency, not both." };
+  }
+  if (named.agency) {
+    return { ok: true, target: { agencyId: named.agency } };
+  }
+  if (named.company) {
+    return { ok: true, target: { companyId: named.company } };
+  }
+  return {
+    ok: false,
+    error: "Name the company with --company <id>, or the agency to onboard with --agency <id>. `baker organization companies` and `baker organization setup clients` list them."
+  };
+}
+function namedTarget(agency) {
+  const company = optionalTargetCompany();
+  clearTargetCompany();
+  const named = setupTarget({ ...company ? { company } : {}, ...agency ? { agency } : {} });
+  if (!named.ok) {
+    failValidation(named.error);
+  }
+  return named.target;
+}
+function stageBody(text, target, chatId) {
+  let raw;
+  try {
+    raw = JSON.parse(text);
+  } catch {
+    return { ok: false, error: "The setup file is not valid JSON." };
+  }
+  const parsed = clientSetupSchema.safeParse(raw);
+  if (!parsed.success) {
+    const issue = parsed.error.issues[0];
+    const where = issue?.path.join(".") || "the setup";
+    return {
+      ok: false,
+      error: `${where}: ${issue?.message ?? "invalid"}. See \`baker schema organization.setup.stage\`.`
+    };
+  }
+  return { ok: true, body: { chatId, ...target, setup: parsed.data } };
+}
+var show = defineCommand2({
+  meta: {
+    name: "show",
+    description: `What kind of setup it is and what it holds, the company's setup as it stands, and what this chat staged for it.
+
+Read it before staging: the question ids it lists are how you reword, answer or remove one.
+
+Examples:
+  baker organization setup show --company <id>
+  baker organization setup show --agency <id>     # an agency to onboard
+
+Full guide: ${DOC}`
+  },
+  args: { agency: AGENCY_ARG },
+  run: async ({ args }) => {
+    const target = namedTarget(args.agency);
+    try {
+      const chatId = optionalChatId();
+      writeJson(
+        await apiGet("/api/organization/setup", {
+          ...target,
+          ...chatId ? { chatId } : {}
+        })
+      );
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var stage = defineCommand2({
+  meta: {
+    name: "stage",
+    description: `Stage a whole setup on this chat, applied when the person publishes.
+
+Only an admin of the organization. Each call replaces what this chat staged for that company or agency.
+
+Examples:
+  baker organization setup stage --company <id> --file setup.json
+  baker organization setup stage --agency <id> --file onboarding.json
+
+Full guide: ${DOC}`
+  },
+  args: {
+    file: { type: "string", description: "The setup as JSON", required: true },
+    agency: AGENCY_ARG
+  },
+  run: async ({ args }) => {
+    const target = namedTarget(args.agency);
+    let text;
+    try {
+      text = readFileSync3(args.file, "utf8");
+    } catch {
+      failValidation(`Cannot read ${args.file}.`);
+    }
+    const built = stageBody(text, target, requireChatId());
+    if (!built.ok) {
+      failValidation(built.error);
+    }
+    try {
+      writeJson(await apiPost("/api/organization/setup/stage", built.body));
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var ATTIO_DIR = "/tmp/baker-attio";
+function attioReport(data, dir) {
+  const { history, ...rest } = data;
+  if (history === void 0) {
+    return { answer: rest, write: null };
+  }
+  const path = join3(dir, `${data.company.id}.md`);
+  return { answer: { ...rest, history: path }, write: { path, text: history } };
+}
+var clients = defineCommand2({
+  meta: {
+    name: "clients",
+    description: `The companies this chat may prepare a setup for. In Baker's own team, for a superadmin, every client that signs with Baker, and the agencies to onboard.
+
+Examples:
+  baker organization setup clients --search acme
+
+Full guide: ${DOC}`
+  },
+  args: {
+    search: { type: "string", description: "Keep companies whose name or website has these words", required: false }
+  },
+  run: async ({ args }) => {
+    try {
+      writeJson(
+        await apiGet("/api/organization/setup/clients", {
+          chatId: requireChatId(),
+          ...args.search ? { search: args.search } : {}
+        })
+      );
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var team = defineCommand2({
+  meta: {
+    name: "team",
+    description: `Baker's own team: our part of a setup \u2014 timeline, contract, company details, welcome email \u2014 as it stands, how to stage it, and the rules for each.
+
+Examples:
+  baker organization setup team --company <id>
+  baker organization setup team --agency <id>
+
+Full guide: ${DOC}`
+  },
+  args: { agency: AGENCY_ARG },
+  run: async ({ args }) => {
+    const target = namedTarget(args.agency);
+    try {
+      const response = await apiGet("/api/organization/setup/team", {
+        ...target,
+        chatId: requireChatId()
+      });
+      process.stdout.write(`${response.data.guide}
+`);
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var attio = defineCommand2({
+  meta: {
+    name: "attio",
+    description: `Baker's own team: what Baker's CRM holds on a client or an agency \u2014 calls with transcripts, notes, logged emails \u2014 saved to a file, with its files.
+
+Examples:
+  baker organization setup attio --company <id>
+  baker organization setup attio --agency <id>
+  baker organization setup attio --company <id> --file-id <id>
+
+Full guide: ${DOC}`
+  },
+  args: {
+    "file-id": { type: "string", description: "One of the record's files, to read as text", required: false },
+    agency: AGENCY_ARG
+  },
+  run: async ({ args }) => {
+    const target = namedTarget(args.agency);
+    const fileId = args["file-id"];
+    try {
+      const response = await apiGet("/api/organization/setup/attio", {
+        ...target,
+        chatId: requireChatId(),
+        ...fileId ? { fileId } : {}
+      });
+      const report = attioReport(response.data, ATTIO_DIR);
+      if (report.write) {
+        mkdirSync2(dirname(report.write.path), { recursive: true });
+        writeFileSync2(report.write.path, report.write.text);
+      }
+      writeJson({ ok: true, data: report.answer });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+async function readSite(body) {
+  try {
+    writeJson(await apiPost("/api/organization/setup/site", body));
+  } catch (err) {
+    failApi(err);
+  }
+}
+var pages = defineCommand2({
+  meta: {
+    name: "pages",
+    description: `A client's website pages, to choose the few that decide its setup.
+
+Examples:
+  baker organization setup pages --url https://acme.com
+  baker organization setup pages --url https://acme.com --search pricing
+
+Full guide: ${DOC}`
+  },
+  args: {
+    url: { type: "string", description: "The client's website", required: true },
+    search: { type: "string", description: "Keep pages whose address has these words", required: false }
+  },
+  run: async ({ args }) => {
+    await readSite({ kind: "pages", url: args.url, ...args.search ? { search: args.search } : {} });
+  }
+});
+var inspect = defineCommand2({
+  meta: {
+    name: "inspect",
+    description: `Visit a client's page as a visitor would: tags that fire, Tag Manager, cookie consent, forms and their fields, what the site is built on and the outside services no tag names.
+
+Slow and paid: the home page, each page with a form, any landing they run. Three visits at most.
+
+Examples:
+  baker organization setup inspect --url https://acme.com
+  baker organization setup inspect --url https://acme.com/quote
+
+Full guide: ${DOC}`
+  },
+  args: { url: { type: "string", description: "The page to visit", required: true } },
+  run: async ({ args }) => {
+    await readSite({ kind: "inspect", url: args.url });
+  }
+});
+var unstage = defineCommand2({
+  meta: {
+    name: "unstage",
+    description: `Take back the setup this chat staged for a company, or an agency's onboarding.
+
+Examples:
+  baker organization setup unstage --company <id>
+  baker organization setup unstage --agency <id>
+
+Full guide: ${DOC}`
+  },
+  args: { agency: AGENCY_ARG },
+  run: async ({ args }) => {
+    const target = namedTarget(args.agency);
+    try {
+      writeJson(
+        await apiPost("/api/organization/setup/unstage", {
+          chatId: requireChatId(),
+          ...target
+        })
+      );
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var setupCommand = defineCommand2({
+  meta: {
+    name: "setup",
+    description: "A setup, prepared here by an admin of the organization \u2014 a company's, or in Baker's own team an agency's onboarding: `show` it, `stage` the whole of it on this chat, applied at Publish."
+  },
+  subCommands: { show, clients, team, attio, pages, inspect, stage, unstage }
+});
+
+// src/commands/organization/index.ts
+registerSchema({
+  command: "organization.companies",
+  description: "Start here in the organization workspace: every company of the organization, with its id and the platforms it has connected. Pass an id to any read with --company <id> (e.g. baker ads meta campaigns --company <id>) to read that company; a platform it has not connected answers 'not connected'. Only the organization workspace can run it, and it can only read.",
+  args: {}
+});
+function companiesHints(companies2) {
+  const hints = [];
+  const first = companies2[0];
+  if (first) {
+    hints.push(
+      `Read one company by adding --company <id> to any read, e.g. \`baker ads meta campaigns --company ${first.id}\`. Writes are refused: a company changes in its own chats.`
+    );
+  }
+  const unconnected = companies2.filter((company) => company.platforms.length === 0);
+  if (unconnected.length > 0) {
+    hints.push(
+      `Not connected to any platform, so every platform read refuses them: ${unconnected.map((c) => c.name).join(", ")}.`
+    );
+  }
+  return hints;
+}
+var companies = defineCommand3({
+  meta: {
+    name: "companies",
+    description: `Every company of the organization, with the platforms each has connected.
+
+Only in the organization workspace, whose Reports read across companies. Every other read is the ordinary command plus --company <id>.
+
+Examples:
+  baker organization companies
+  baker ads meta campaigns --company <id>
+  baker ads google campaigns list --company <id>
+
+Full guide: __tooling__/docs/tools/baker/organization.md`
+  },
+  args: {},
+  run: async () => {
+    try {
+      const response = await apiGet("/api/organization/companies");
+      const hints = companiesHints(response.data);
+      writeJson({ ...response, meta: { count: response.data.length }, ...hints.length > 0 ? { hints } : {} });
+    } catch (err) {
+      failApi(err);
+    }
+  }
+});
+var organizationCommand = defineCommand3({
+  meta: {
+    name: "organization",
+    description: "The organization workspace: the companies its Reports read. Start with `baker organization companies`; read any of them with --company <id>; download what each made with `baker organization pull`; prepare a company's setup with `baker organization setup`."
+  },
+  subCommands: { companies, pull: pullCommand, setup: setupCommand }
+});
+export {
+  companiesHints,
+  organizationCommand
+};
+//# sourceMappingURL=organization-A4NFWWWI.js.map