@wjarka/cezarion 0.10.0-pr30.54

package/dist/workspace/ui-state.d.ts

@@ -0,0 +1,34 @@
+import type { WorkspaceUiState } from '../contract/index.js';
+/**
+ * `~/.cezar/ui-state.json` — global GUI state, the workspace twin of the
+ * per-repo `.ai/cezar/ui-state.json` (spec 2026-07-20-multi-project-workspace,
+ * Data Model). Same split as `src/ui-state.ts`: this module owns the tolerant
+ * read and the atomic write; the schema and key cap live at the route boundary
+ * (`GET/PUT /api/workspace/ui-state`, step 2.7). The state is an opaque
+ * `.passthrough()`-style bag — cross-project prefs (appearance, notifications,
+ * curated skills) live here; project-scoped prefs stay in each repo's own file,
+ * and prefs that describe the BROWSER rather than the workspace (sidebar
+ * collapse, the last visited location) stay in that browser's localStorage.
+ */
+/** Read `~/.cezar/ui-state.json` on demand — never cached, never throws.
+ *  Missing, unreadable, malformed, or non-object all degrade to `{}`.
+ *
+ *  Typed by the CONTRACT (`WorkspaceUiState`) for the same reason as its per-repo twin in
+ *  `src/ui-state.ts`: `GET /api/v1/workspace/ui-state` answers this value verbatim, so a loose
+ *  record left the route naming no key. The schema is a `z.looseObject`, so unknown prefs keep
+ *  round-tripping (BACKWARD_COMPATIBILITY.md §3) — the type only adds the known names. */
+export declare function readWorkspaceUiState(path?: string): Promise<WorkspaceUiState>;
+/**
+ * Read-modify-write for `~/.cezar/ui-state.json`, written with the same atomic
+ * per-writer tmp+rename `0600` pattern (dir `0700`) as
+ * `mergeWriteWorkspaceConfig` (`atomicWriteJsonSync` — one shared writer, so
+ * the unique-tmp rule cannot drift between the two files). A missing or
+ * corrupt file merges from `{}`. The mutator may mutate its argument in place
+ * or return a replacement. Throws on write failure (e.g. a read-only home) —
+ * degrading is the caller's policy, per house rules.
+ *
+ * Path resolved once, before the `await`, for the same reason as
+ * `mergeWriteWorkspaceConfig`: a `CEZ_HOME` that changes mid-flight must not be
+ * able to send the read and the write to two different files.
+ */
+export declare function mergeWriteWorkspaceUiState(mutator: (state: WorkspaceUiState) => WorkspaceUiState | void): Promise<WorkspaceUiState>;

package/dist/workspace/ui-state.js

@@ -0,0 +1,53 @@
+import { readFile } from 'node:fs/promises';
+import { workspaceUiStatePath } from '../paths.js';
+import { atomicWriteJsonSync } from './config.js';
+/**
+ * `~/.cezar/ui-state.json` — global GUI state, the workspace twin of the
+ * per-repo `.ai/cezar/ui-state.json` (spec 2026-07-20-multi-project-workspace,
+ * Data Model). Same split as `src/ui-state.ts`: this module owns the tolerant
+ * read and the atomic write; the schema and key cap live at the route boundary
+ * (`GET/PUT /api/workspace/ui-state`, step 2.7). The state is an opaque
+ * `.passthrough()`-style bag — cross-project prefs (appearance, notifications,
+ * curated skills) live here; project-scoped prefs stay in each repo's own file,
+ * and prefs that describe the BROWSER rather than the workspace (sidebar
+ * collapse, the last visited location) stay in that browser's localStorage.
+ */
+/** Read `~/.cezar/ui-state.json` on demand — never cached, never throws.
+ *  Missing, unreadable, malformed, or non-object all degrade to `{}`.
+ *
+ *  Typed by the CONTRACT (`WorkspaceUiState`) for the same reason as its per-repo twin in
+ *  `src/ui-state.ts`: `GET /api/v1/workspace/ui-state` answers this value verbatim, so a loose
+ *  record left the route naming no key. The schema is a `z.looseObject`, so unknown prefs keep
+ *  round-tripping (BACKWARD_COMPATIBILITY.md §3) — the type only adds the known names. */
+export async function readWorkspaceUiState(path = workspaceUiStatePath()) {
+    try {
+        const parsed = JSON.parse(await readFile(path, 'utf8'));
+        return parsed !== null && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Read-modify-write for `~/.cezar/ui-state.json`, written with the same atomic
+ * per-writer tmp+rename `0600` pattern (dir `0700`) as
+ * `mergeWriteWorkspaceConfig` (`atomicWriteJsonSync` — one shared writer, so
+ * the unique-tmp rule cannot drift between the two files). A missing or
+ * corrupt file merges from `{}`. The mutator may mutate its argument in place
+ * or return a replacement. Throws on write failure (e.g. a read-only home) —
+ * degrading is the caller's policy, per house rules.
+ *
+ * Path resolved once, before the `await`, for the same reason as
+ * `mergeWriteWorkspaceConfig`: a `CEZ_HOME` that changes mid-flight must not be
+ * able to send the read and the write to two different files.
+ */
+export async function mergeWriteWorkspaceUiState(mutator) {
+    const path = workspaceUiStatePath();
+    const current = await readWorkspaceUiState(path);
+    const next = mutator(current) ?? current;
+    atomicWriteJsonSync(path, next);
+    return next;
+}
+//# sourceMappingURL=ui-state.js.map

package/dist/workspace/ui-state.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-state.js","sourceRoot":"","sources":["../../src/workspace/ui-state.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAC;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAElD;;;;;;;;;;GAUG;AAEH;;;;;;0FAM0F;AAC1F,MAAM,CAAC,KAAK,UAAU,oBAAoB,CACxC,IAAI,GAAW,oBAAoB,EAAE;IAErC,IAAI,CAAC;QACH,MAAM,MAAM,GAAY,IAAI,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;QACjE,OAAO,MAAM,KAAK,IAAI,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC;YAC5E,CAAC,CAAE,MAA2B;YAC9B,CAAC,CAAC,EAAE,CAAC;IACT,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,0BAA0B,CAC9C,OAA6D;IAE7D,MAAM,IAAI,GAAG,oBAAoB,EAAE,CAAC;IACpC,MAAM,OAAO,GAAG,MAAM,oBAAoB,CAAC,IAAI,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,IAAI,OAAO,CAAC;IACzC,mBAAmB,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;IAChC,OAAO,IAAI,CAAC;AACd,CAAC"}

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@wjarka/cezarion",
+  "version": "0.10.0-pr30.54",
+  "description": "Local cockpit for running and tracking AI agent tasks in your repo. Uses your logged-in `claude` CLI and `gh` — zero config, zero database.",
+  "license": "MIT",
+  "type": "module",
+  "bin": {
+    "cezarion": "dist/index.js",
+    "cez": "dist/index.js"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./app-type": "./dist/server/app-type.js",
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "web/dist",
+    "scripts",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "prebuild": "node scripts/sync-readme.mjs",
+    "build": "tsc",
+    "check:pack": "node scripts/check-pack.mjs",
+    "dev": "tsx src/index.ts",
+    "install-as-command": "node scripts/install-as-command.mjs --mode link",
+    "install-as-command:global": "node scripts/install-as-command.mjs --mode global",
+    "uninstall-as-command": "node scripts/install-as-command.mjs --mode uninstall",
+    "server-install": "tsx src/index.ts server-install",
+    "server-deploy": "tsx src/index.ts server-deploy",
+    "server-uninstall": "tsx src/index.ts server-uninstall",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:unit": "node --import tsx --test test/unit/*.test.ts",
+    "test:package": "node --import tsx --test test/e2e/*.test.ts",
+    "typecheck": "tsc --noEmit -p tsconfig.test.json",
+    "postbuild": "node scripts/inline-contract.mjs"
+  },
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "@hono/node-server": "^1.13.0",
+    "hono": "^4.6.0",
+    "smol-toml": "^1.7.0",
+    "ws": "^8.21.1",
+    "yaml": "^2.5.0",
+    "zod": "^4.4.3"
+  },
+  "devDependencies": {
+    "@open-mercato/cezar-api-client": "0.10.0-pr30.54",
+    "@open-mercato/cezar-contract": "0.10.0-pr30.54",
+    "@types/node": "^20.14.0",
+    "@types/ws": "^8.18.1",
+    "esbuild": "^0.28.1",
+    "tsx": "^4.19.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/wjarka/cezar",
+    "directory": "packages/cezar"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/scripts/check-pack.mjs

@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+// Tarball bundle check (`npm run check:pack`, last leg of `npm run build`):
+// fail loudly when the published package would ship without the built UI —
+// phase R1 of the cockpit redesign once published a tarball with no cockpit
+// in it, and this pins that bug class before every publish (prepublishOnly →
+// build → check:pack).
+//
+// Asks npm itself what it would pack (`npm pack --dry-run --json`) and hands
+// the file list to the pure, unit-tested decision in src/pack-check.ts.
+// Imports from dist/, so it must run AFTER `tsc` — `npm run build` orders
+// tsc → build:web → check:pack, which also guarantees web/dist exists in a
+// fresh checkout by the time the check looks for it.
+
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { findPackGaps } from '../dist/pack-check.js';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+
+// Under `npm run`, npm_execpath is npm's own cli.js — running it through
+// process.execPath works on every platform (no .cmd shim needed on Windows).
+const npmExecpath = process.env.npm_execpath;
+const packArgs = ['pack', '--dry-run', '--json'];
+const npmCli = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+const stdout = npmExecpath
+  ? execFileSync(process.execPath, [npmExecpath, ...packArgs], { cwd: repoRoot, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 })
+  : execFileSync(npmCli, packArgs, { cwd: repoRoot, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024, shell: process.platform === 'win32' });
+
+/** @type {{ files?: { path: string }[] }[]} */
+const reports = JSON.parse(stdout);
+const files = (reports[0]?.files ?? []).map((f) => f.path);
+if (files.length === 0) {
+  console.error('check:pack: `npm pack --dry-run --json` reported no files — refusing to publish an empty package');
+  process.exit(1);
+}
+
+const gaps = findPackGaps(files);
+if (gaps.length > 0) {
+  console.error('check:pack: the npm tarball would ship a broken cockpit:');
+  for (const gap of gaps) console.error(`  - ${gap}`);
+  process.exit(1);
+}
+
+const uiFiles = files.filter((f) => f.startsWith('web/dist/')).length;
+console.log(`check:pack ok — ${files.length} files, ${uiFiles} under web/dist (shell + assets present)`);

package/scripts/inline-contract.mjs

@@ -0,0 +1,112 @@
+/**
+ * Bundle `@open-mercato/cezar-contract` into `dist` after `tsc`.
+ *
+ * The contract and the api-client are PRIVATE and ship no build of their own — they are linked as
+ * workspace packages and consumed as TypeScript source, which is what every other consumer wants:
+ * the cockpit's Vite bundles them, vitest transforms them.
+ *
+ * This package is the exception, because it is PUBLISHED. `workspace/migrations.ts` imports
+ * `workspaceUiStateSchema` — a zod value, not a type — so the installed CLI resolves the contract
+ * at runtime, and a tarball naming a package npm has never seen would fail on install. So the
+ * build folds it in: esbuild compiles the contract's source to one ESM file under `dist/contract/`,
+ * `tsc` emits its declarations beside it, and the emitted references are repointed at both.
+ *
+ * Nothing is copied at the SOURCE level — the package graph still states the dependency, and this
+ * runs only when `dist` actually names it. Delete this the day the contract is published, or the
+ * day nothing here imports a contract VALUE.
+ *
+ * DECLARATIONS ship next to the bundle, and that is not optional. The scan below matches `.d.ts`
+ * as well as `.js`, so emitted type imports get repointed too (`dist/ui-state.d.ts` names
+ * `WorkspaceUiState`). esbuild emits JavaScript only, so a bundle on its own leaves those
+ * declarations naming a module TypeScript cannot resolve — `TS7016`, and the type silently
+ * degrades to `any` for anyone consuming the published package. Every tsconfig here sets
+ * `skipLibCheck`, so nothing in this repo would have said a word. `tsc --emitDeclarationOnly`
+ * mirrors the contract's `src` tree into `dist/contract/`, which is what makes
+ * `./contract/index.js` resolve to a real `./contract/index.d.ts`.
+ */
+import { execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { existsSync, readdirSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
+import { dirname, join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { build } from 'esbuild';
+
+const here = dirname(fileURLToPath(import.meta.url));
+const dist = join(here, '..', 'dist');
+const contractRoot = join(here, '..', '..', 'contract');
+const entry = join(contractRoot, 'src', 'index.ts');
+const outdir = join(dist, 'contract');
+const SPEC = /(['"])@open-mercato\/cezar-contract\1/g;
+
+/** Emitted files that name the package — the copy happens only if it is really used. */
+const referrers = [];
+const scan = (dir) => {
+  for (const entry of readdirSync(dir, { withFileTypes: true })) {
+    const p = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (p !== outdir) scan(p);
+    } else if (/\.(js|d\.ts|js\.map)$/.test(entry.name)) {
+      SPEC.lastIndex = 0;
+      if (SPEC.test(readFileSync(p, 'utf8'))) referrers.push(p);
+    }
+  }
+};
+scan(dist);
+
+rmSync(outdir, { recursive: true, force: true });
+if (referrers.length === 0) {
+  console.log('inline-contract ok — nothing in dist references the contract, nothing bundled');
+  process.exit(0);
+}
+
+// `zod` stays external: it is a real dependency of this package, so npm resolves it normally and
+// the tarball does not carry a second copy.
+await build({
+  entryPoints: [entry],
+  outfile: join(outdir, 'index.js'),
+  bundle: true,
+  format: 'esm',
+  platform: 'neutral',
+  target: 'es2022',
+  external: ['zod'],
+});
+
+// `tsc` is located through the module graph rather than a guessed `node_modules` path, because
+// `typescript` is a devDependency of THIS package and may sit here or be hoisted to the workspace
+// root. Via the manifest's own `bin` entry: TypeScript 7's `exports` map does not publish
+// `./bin/tsc`, so resolving that subpath directly is ERR_PACKAGE_PATH_NOT_EXPORTED.
+const require_ = createRequire(import.meta.url);
+const tsManifest = require_.resolve('typescript/package.json');
+const tscBin = join(dirname(tsManifest), require_(tsManifest).bin.tsc);
+
+// The declarations for the bundle above. `tsc` mirrors `src/**` into `outdir`, so `index.d.ts`
+// lands beside `index.js` and its relative siblings (`./health.js` → `./health.d.ts`) resolve as
+// TypeScript expects. Those siblings have no runtime twin, which is correct: the bundle is
+// self-contained and nothing imports those paths at runtime.
+execFileSync(
+  process.execPath,
+  [
+    tscBin,
+    '--project',
+    join(contractRoot, 'tsconfig.json'),
+    '--emitDeclarationOnly',
+    '--declarationMap',
+    'false',
+    '--sourceMap',
+    'false',
+    '--outDir',
+    outdir,
+  ],
+  { stdio: 'inherit' },
+);
+if (!existsSync(join(outdir, 'index.d.ts'))) {
+  console.error('inline-contract: tsc emitted no index.d.ts — the bundled contract would ship untyped');
+  process.exit(1);
+}
+
+for (const p of referrers) {
+  let rel = relative(dirname(p), join(outdir, 'index.js')).replaceAll('\\', '/');
+  if (!rel.startsWith('.')) rel = `./${rel}`;
+  writeFileSync(p, readFileSync(p, 'utf8').replace(SPEC, `'${rel}'`), 'utf8');
+}
+console.log(`inline-contract ok — contract bundled with declarations, ${referrers.length} file(s) repointed`);

package/scripts/install-as-command.mjs

@@ -0,0 +1,120 @@
+#!/usr/bin/env node
+// `npm run install-as-command` (+ `:global` and the `uninstall-as-command`
+// counterpart): build this checkout and put a global `cezarion`/`cez`
+// command on PATH pointing at THIS working tree — the local-dev equivalent of
+// `npx cezarion`, with no publish and no `npx` download. Spec 013.
+//
+//   --mode link       build → `npm link`             (live; `npm run build` refreshes it)
+//   --mode global     build → `npm install --global .` (self-contained snapshot)
+//   --mode uninstall                  `npm rm --global @wjarka/cezarion`
+//   --no-build        skip the build (relink an already-built dist)
+//
+// The install decisions live in the unit-tested src/install-as-command.ts
+// (compiled to dist by the build); this script owns spawning + exit codes.
+// npm is invoked through process.execPath + npm_execpath — same cross-platform
+// pattern as scripts/dev.mjs / scripts/check-pack.mjs (no .cmd shim assumptions).
+
+import { spawnSync, execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const repoRoot = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+const argv = process.argv.slice(2);
+
+const modeIdx = argv.indexOf('--mode');
+const mode = modeIdx >= 0 ? argv[modeIdx + 1] : 'link';
+const noBuild = argv.includes('--no-build');
+if (!['link', 'global', 'uninstall'].includes(mode)) {
+  console.error(`install-as-command: unknown --mode "${mode}" (expected link | global | uninstall)`);
+  process.exit(1);
+}
+
+// npm invocation shim (identical to dev.mjs / check-pack.mjs).
+const npmExecpath = process.env.npm_execpath;
+const npmCli = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+function npm(args, { capture = false } = {}) {
+  const viaNode = Boolean(npmExecpath);
+  const file = viaNode ? process.execPath : npmCli;
+  const full = viaNode ? [npmExecpath, ...args] : args;
+  const shell = !viaNode && process.platform === 'win32';
+  if (capture) {
+    return execFileSync(file, full, { cwd: repoRoot, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024, shell });
+  }
+  const res = spawnSync(file, full, { cwd: repoRoot, stdio: 'inherit', shell });
+  return res.status ?? 1;
+}
+
+const distDir = path.join(repoRoot, 'dist');
+const build = mode !== 'uninstall' && !noBuild;
+
+if (mode !== 'uninstall' && noBuild && !existsSync(path.join(distDir, 'index.js'))) {
+  console.error('install-as-command: --no-build was set but dist/ is missing — run once without --no-build first.');
+  process.exit(1);
+}
+
+if (build) {
+  console.log('install-as-command: building (npm run build)…');
+  const code = npm(['run', 'build']);
+  if (code !== 0) {
+    console.error('install-as-command: build failed — nothing installed.');
+    process.exit(code);
+  }
+}
+
+// Load the tested planner from dist. Present after any build; for uninstall on a
+// never-built checkout it may be absent, so fall back to the known command.
+let planner = null;
+const plannerPath = path.join(distDir, 'install-as-command.js');
+if (existsSync(plannerPath)) {
+  planner = await import(pathToFileURL(plannerPath).href);
+}
+const PACKAGE_NAME = planner?.PACKAGE_NAME ?? '@wjarka/cezarion';
+const steps = planner
+  ? planner.planInstall({ mode, build }).steps
+  : [{ args: ['rm', '--global', PACKAGE_NAME], label: `remove global ${PACKAGE_NAME}` }];
+
+for (const step of steps) {
+  console.log(`install-as-command: npm ${step.args.join(' ')} (${step.label})`);
+  const code = npm(step.args);
+  if (code !== 0) {
+    if (mode === 'uninstall') {
+      // Idempotent: `npm rm -g` of an absent package is a no-op success.
+      console.log('install-as-command: nothing to uninstall (already absent).');
+      break;
+    }
+    console.error(`install-as-command: \`npm ${step.args.join(' ')}\` failed (see npm output above).`);
+    console.error(
+      '  If this is an EACCES on a root-owned global prefix, set a user-writable one\n' +
+        '  (e.g. `npm config set prefix ~/.npm-global`) and retry — do NOT use sudo.',
+    );
+    process.exit(code);
+  }
+}
+
+if (mode === 'uninstall') {
+  console.log('install-as-command: global cezarion / cez removed.');
+  process.exit(0);
+}
+
+// Verify the shims and print a PATH hint.
+let prefix = '';
+try {
+  prefix = npm(['prefix', '--global'], { capture: true }).trim();
+} catch {
+  // best-effort — the install already succeeded above
+}
+if (planner && prefix) {
+  const binDir = planner.globalBinDir(prefix, process.platform);
+  const present = planner.globalShimPaths(prefix, process.platform).filter((p) => existsSync(p));
+  const names = planner.BIN_NAMES.join(', ');
+  if (present.length === planner.BIN_NAMES.length) {
+    console.log(`\ninstall-as-command: installed ${names} → ${binDir}`);
+  } else {
+    console.log(`\ninstall-as-command: done, but only ${present.length}/${planner.BIN_NAMES.length} shims found in ${binDir}`);
+  }
+  console.log(`  Ensure this is on your PATH:\n    ${binDir}`);
+  console.log('  Then, from any repo:  cez --help');
+} else {
+  console.log('\ninstall-as-command: done. Ensure your npm global bin dir is on PATH, then run `cez --help`.');
+}