ompchamber 3.5.0 → 3.6.0

package/src/server/lib/omp/config/commands.ts

@@ -0,0 +1,195 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Command (slash-command) file location and authoring for the chamber's
+ * Commands settings.
+ *
+ * omp discovers markdown slash commands from every provider's config dirs and
+ * `get_available_commands` reports them by name, description and argument hint
+ * — but never by path, and never with the scope it found them at. The chamber
+ * needs both to answer "is this a user-scope command or a project-scope one,
+ * and may I edit it?", so this module probes the same directories omp reads.
+ *
+ * Two levels, probed project-first (omp resolves a name present in both roots
+ * to the project file — verified: `dupe.md` in `~/.omp/agent/commands` and in a
+ * workspace's `.omp/commands` runs the project body):
+ *
+ * - project: `<workspace>/.omp/commands`, `.claude/commands`, `.codex/commands`,
+ *   `.agents/commands`, `.opencode/commands`, `.github/prompts/*.prompt.md`
+ * - user: `~/.omp/agent/commands`, `~/.claude/commands`, `~/.codex/commands`,
+ *   `~/.agents/commands`, `~/.config/opencode/commands`
+ *
+ * Only the two omp-native `.omp` roots are `managed`: a command from `.claude`
+ * or `.agents` is shown read-only, because the chamber is not the tool that put
+ * it there and a save or delete through this pane would rewrite another tool's
+ * file. A nested Claude command is addressed as `ns:name` by omp and stored as
+ * `<dir>/ns/name.md`, which is why a colon maps to a path separator here.
+ */
+
+import fs from 'fs';
+import { join, resolve } from 'path';
+import { getAgentDir, pathExists } from '@/server/lib/omp/core/paths';
+import { writeFileAtomic } from '@/server/lib/fs/atomic-write';
+import { parseFrontmatter } from '@/server/lib/omp/config/yaml';
+
+const MAX_COMMAND_MD_BYTES = 512 * 1024;
+
+/** Project-level command dirs, relative to a workspace root. `github` holds
+ *  VS Code Copilot prompt files, whose names carry the `.prompt` suffix. */
+const PROJECT_COMMAND_DIRS: Array<{ dir: string; suffix: string }> = [
+  { dir: '.omp/commands', suffix: '.md' },
+  { dir: '.claude/commands', suffix: '.md' },
+  { dir: '.codex/commands', suffix: '.md' },
+  { dir: '.agents/commands', suffix: '.md' },
+  { dir: '.opencode/commands', suffix: '.md' },
+  { dir: '.github/prompts', suffix: '.prompt.md' },
+];
+
+/** User-level command dirs. `.omp/agent` comes from the agent dir resolution
+ *  so `PI_CODING_AGENT_DIR` and profiles are honored. */
+function userCommandDirs(): Array<{ dir: string; suffix: string }> {
+  return [
+    { dir: join(getAgentDir(), 'commands'), suffix: '.md' },
+    { dir: join(Bun.env.HOME ?? '', '.claude', 'commands'), suffix: '.md' },
+    { dir: join(Bun.env.HOME ?? '', '.codex', 'commands'), suffix: '.md' },
+    { dir: join(Bun.env.HOME ?? '', '.agents', 'commands'), suffix: '.md' },
+    { dir: join(Bun.env.HOME ?? '', '.config', 'opencode', 'commands'), suffix: '.md' },
+  ];
+}
+
+export interface CommandFileLocation {
+  filePath: string;
+  scope: 'user' | 'project';
+  /** True for the two omp-native roots the chamber may write and delete in. */
+  managed: boolean;
+}
+
+/** A command name that is safe as a relative path inside a command dir. */
+function safeRelativeName(name: string): string | null {
+  const trimmed = name.trim().replace(/^\/+/, '');
+  if (!trimmed) return null;
+  if (/[\\/]/.test(trimmed.replace(/:/g, '/')) || trimmed === '.' || trimmed === '..') return null;
+  return trimmed;
+}
+
+/** The file backing a command, or null when it is not a markdown command file
+ *  (a builtin, a skill, an extension command) or was not found in any root. */
+export async function locateCommandFile(
+  name: string,
+  projectDir?: string | null,
+): Promise<CommandFileLocation | null> {
+  const relative = safeRelativeName(name);
+  if (!relative) return null;
+  const asPath = relative.replace(/:/g, '/');
+
+  const candidates: Array<{ dir: string; suffix: string; scope: 'user' | 'project'; managed: boolean }> = [];
+  if (projectDir) {
+    for (const entry of PROJECT_COMMAND_DIRS) {
+      candidates.push({ ...entry, dir: join(projectDir, entry.dir), scope: 'project', managed: entry.dir === '.omp/commands' });
+    }
+  }
+  for (const entry of userCommandDirs()) {
+    candidates.push({ ...entry, scope: 'user', managed: entry.dir === join(getAgentDir(), 'commands') });
+  }
+
+  for (const candidate of candidates) {
+    const filePath = join(candidate.dir, `${asPath}${candidate.suffix}`);
+    if (await pathExists(filePath)) {
+      return { filePath, scope: candidate.scope, managed: candidate.managed };
+    }
+  }
+  return null;
+}
+
+/** Read a command markdown file, split into frontmatter fields and template. */
+export async function readCommandFile(
+  filePath: string,
+): Promise<{ description: string; argumentHint: string; body: string } | null> {
+  try {
+    const file = Bun.file(filePath);
+    if (!(await file.exists()) || (await file.stat()).size > MAX_COMMAND_MD_BYTES) return null;
+    const { data, body } = parseFrontmatter(await file.text());
+    return {
+      description: data.description ?? '',
+      argumentHint: data['argument-hint'] ?? data.argumentHint ?? '',
+      body: body.replace(/^\r?\n/, ''),
+    };
+  } catch {
+    return null;
+  }
+}
+
+/** Serialize a command markdown file. omp reads `description` and
+ *  `argument-hint` from frontmatter; the body is the prompt template. */
+function serializeCommandMd(input: { description: string; argumentHint: string; body: string }): string {
+  const lines = ['---'];
+  if (input.description) lines.push(`description: ${JSON.stringify(input.description)}`);
+  if (input.argumentHint) lines.push(`argument-hint: ${JSON.stringify(input.argumentHint)}`);
+  lines.push('---', '', input.body.replace(/\r\n/g, '\n').replace(/\s*$/, ''), '');
+  return lines.join('\n');
+}
+
+export interface WriteCommandInput {
+  /** Target root: `user` writes to the agent dir, `project` to the workspace. */
+  scope: 'user' | 'project';
+  /** Workspace root, required for `project`. */
+  projectDir?: string | null;
+  /** Name of the command being edited, when it is being renamed. */
+  previousName?: string | null;
+  name: string;
+  description: string;
+  argumentHint: string;
+  body: string;
+}
+
+/** Create or overwrite a chamber-managed command file. Refuses a project write
+ *  with no workspace rather than landing it somewhere the user did not pick. */
+export async function writeCommandFile(input: WriteCommandInput): Promise<{ filePath: string }> {
+  const relative = safeRelativeName(input.name);
+  if (!relative) throw new Error('Command name is required');
+  if (input.scope === 'project' && !input.projectDir) {
+    throw new Error('A workspace root is required to write a project command');
+  }
+  const root = input.scope === 'project'
+    ? join(input.projectDir!, '.omp', 'commands')
+    : join(getAgentDir(), 'commands');
+  const filePath = join(root, `${relative.replace(/:/g, '/')}.md`);
+
+  // A rename is a move: the previous file must not linger as a second command.
+  // It is removed only when it is a DIFFERENT managed file, so an edit in place
+  // never deletes the file just written.
+  const previous = input.previousName?.trim().replace(/^\/+/, '');
+  if (previous && previous !== relative) {
+    const stale = await locateCommandFile(previous, input.projectDir);
+    if (stale?.managed && resolve(stale.filePath) !== resolve(filePath)) {
+      await fs.promises.rm(stale.filePath, { force: true });
+    }
+  }
+
+  await fs.promises.mkdir(resolve(filePath, '..'), { recursive: true });
+  await writeFileAtomic(
+    filePath,
+    serializeCommandMd({
+      description: input.description,
+      argumentHint: input.argumentHint,
+      body: input.body,
+    }),
+    { createMode: 0o644 },
+  );
+  return { filePath };
+}
+
+/** Delete a chamber-managed command file. Refused unless the name resolves to
+ *  one of the managed roots, so a delete can never reach another tool's file. */
+export async function deleteCommandFile(name: string, projectDir?: string | null): Promise<boolean> {
+  const found = await locateCommandFile(name, projectDir);
+  if (!found) throw new Error(`"${name}" is not a command file the chamber can delete`);
+  if (!found.managed) {
+    throw new Error(`"${name}" is provided by ${found.filePath}; the chamber cannot delete it`);
+  }
+  await fs.promises.rm(found.filePath, { force: true });
+  return true;
+}

package/src/server/lib/omp/config/scope.test.ts

@@ -0,0 +1,49 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The scope a skills/commands read is answered for.
+ *
+ * The rules worth locking are the fallbacks, because each one silently answers
+ * a DIFFERENT inventory rather than failing: a blank root must keep the
+ * historical app-root meaning (the composer's request for a session with no
+ * workspace folder), `scope=user` must win over a root a stale client still
+ * sends, and an unreadable root must fall back to the user scope rather than a
+ * directory the caller never asked about.
+ */
+
+import { describe, expect, test } from 'bun:test';
+
+import { resolveDiscoveryScope } from '@/server/lib/omp/config/scope';
+import { getAgentDir } from '@/server/lib/omp/core/paths';
+
+const APP_ROOT = process.cwd();
+
+describe('resolveDiscoveryScope', () => {
+  test('scope=user reads the agent dir with no writable workspace', async () => {
+    expect(await resolveDiscoveryScope(null, 'user')).toEqual({ workspace: null, cwd: getAgentDir() });
+  });
+
+  test('scope=user wins over a root, so a stale client cannot resurrect one', async () => {
+    expect(await resolveDiscoveryScope(APP_ROOT, 'user')).toEqual({ workspace: null, cwd: getAgentDir() });
+  });
+
+  test('no root keeps the app root as an unscoped workspace', async () => {
+    expect(await resolveDiscoveryScope(null)).toEqual({ workspace: APP_ROOT, cwd: APP_ROOT });
+    expect(await resolveDiscoveryScope('  ')).toEqual({ workspace: APP_ROOT, cwd: APP_ROOT });
+  });
+
+  test('a real directory under the app root is the workspace it names', async () => {
+    const sub = `${APP_ROOT}/src`;
+    expect(await resolveDiscoveryScope(sub)).toEqual({ workspace: sub, cwd: sub });
+  });
+
+  test('an unreadable root falls back to the user scope', async () => {
+    expect(await resolveDiscoveryScope(`${APP_ROOT}/__no_such_dir__`)).toEqual({
+      workspace: null,
+      cwd: getAgentDir(),
+    });
+  });
+});

package/src/server/lib/omp/config/scope.ts

@@ -0,0 +1,65 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * The discovery scope a skills/commands read is answered for.
+ *
+ * omp resolves project-scope skills and commands from the process cwd: a child
+ * started in a workspace reports that workspace's `.omp/skills`,
+ * `.omp/commands`, `.claude/commands`, `.agents/*` and `.github/*` entries,
+ * while a child started elsewhere reports only the user-level ones. So the
+ * scope is never a filter applied after the fact — it is which directory omp
+ * is asked about, and which roots a write may land in.
+ *
+ * Verified against omp 18.4.0:
+ * - `omp skill list <repo>` reports `native:project` entries (`pr-review`,
+ *   `issue-intake` in this repository) that `omp skill list ~/.omp/agent` does
+ *   not, and both report the `native:user`/`agents:user` ones.
+ * - `get_available_commands` in a workspace reports its `.omp/commands` files
+ *   (`projprobe`) plus the user-level ones (`userprobe`, `~/.claude/commands`),
+ *   while a child in `~/.omp/agent` reports only the latter — and a child in
+ *   `$HOME` reports neither the workspace's nor `~/.omp/agent/commands`, which
+ *   is why the USER scope has a cwd of its own instead of "no cwd".
+ * - A duplicate name in both roots resolves to the PROJECT file (measured:
+ *   `dupe.md` in `~/.omp/agent/commands` and the workspace ran the project
+ *   body), which is why a managed-file lookup checks the workspace first.
+ *
+ * `resolveRoot` gates a client-supplied path (the app root, a path beneath it,
+ * or an exact registered `project_path`). The user scope bypasses it because
+ * its cwd is server-derived, never client-supplied, and an unresolvable root
+ * falls back to the user scope rather than answering with a directory the
+ * caller never asked about.
+ */
+
+import { getAgentDir } from '@/server/lib/omp/core/paths';
+import { resolveRoot } from '@/server/lib/fs/root';
+
+export interface DiscoveryScope {
+  /** Workspace root a write/delete may target, or null for the user scope. */
+  workspace: string | null;
+  /** The cwd omp is asked about: the workspace, the agent dir (user scope),
+   *  or the app root for an unscoped read. */
+  cwd: string;
+}
+
+/**
+ * Resolve the `?root=` / `?scope=` a skills/commands request carries.
+ *
+ * - `scope=user` → the user scope: the agent dir as cwd, no workspace.
+ * - `root=<path>` → that workspace (gated by `resolveRoot`).
+ * - neither → the app root, which is what an unscoped request has always meant
+ *   (the composer's fallback for a session with no workspace folder, where omp
+ *   itself spawns in the server's cwd). It stays a workspace because the app
+ *   root is a registered root the chamber may write in.
+ */
+export async function resolveDiscoveryScope(
+  rawRoot: string | null | undefined,
+  rawScope?: string | null,
+): Promise<DiscoveryScope> {
+  if (rawScope === 'user') return { workspace: null, cwd: getAgentDir() };
+  if (!rawRoot || !rawRoot.trim()) return { workspace: process.cwd(), cwd: process.cwd() };
+  const resolved = await resolveRoot(rawRoot, '');
+  return resolved ? { workspace: resolved, cwd: resolved } : { workspace: null, cwd: getAgentDir() };
+}

package/src/server/lib/omp/config/skills-catalog.ts

@@ -77,11 +77,43 @@ async function runBunxSkills(args: string[]): Promise<string> {
   return stdout;
 }
 
-/** Install a catalog skill into the omp agent skill root. */
-export async function installCatalogSkill(pkg: string): Promise<{ output: string }> {
+/**
+ * Install a catalog skill into the omp agent skill root.
+ *
+ * `--skill` is what keeps the install scoped to the entry the user clicked:
+ * the catalog lists individual skills, and a repository can hold twenty of
+ * them, so an unscoped `skills add <repo>` installs every skill in the repo
+ * (measured: 20 directories landed for one "Install" on a single-skill row).
+ * `--agent universal` writes to `~/.agents/skills`, which is the root omp's
+ * `agents` provider reads.
+ */
+export async function installCatalogSkill(pkg: string, skillName?: string | null): Promise<{ output: string }> {
   if (!/^[\w.\-]+\/[\w.\-@:]+$/.test(pkg)) throw new Error('Invalid skill package');
   if (isMockMode()) throw new Error('Skill install is unavailable in mock mode');
-  const output = await runBunxSkills(['add', pkg, '--agent', 'universal', '-g', '-y']);
+  const name = skillName?.trim();
+  if (name && !/^[\w.\-]+$/.test(name)) throw new Error('Invalid skill name');
+  const output = await runBunxSkills([
+    'add',
+    pkg,
+    '--agent',
+    'universal',
+    ...(name ? ['--skill', name] : []),
+    '-g',
+    '-y',
+  ]);
+  return { output: output.slice(-4000) };
+}
+
+/**
+ * Uninstall a catalog skill by name. `skills remove` is the counterpart of the
+ * `skills add` above and clears the symlink/copy the install created, which is
+ * what a catalog "Uninstall" has to undo — deleting the entry from the chamber's
+ * own store would leave the skill running in omp.
+ */
+export async function uninstallCatalogSkill(name: string): Promise<{ output: string }> {
+  if (!/^[\w.\-@/]+$/.test(name)) throw new Error('Invalid skill name');
+  if (isMockMode()) throw new Error('Skill uninstall is unavailable in mock mode');
+  const output = await runBunxSkills(['remove', name, '-g', '-y']);
   return { output: output.slice(-4000) };
 }
 

package/src/server/lib/omp/config/skills.test.ts

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Chamber-managed SKILL.md authoring: which root a scope writes into, what a
+ * move between roots leaves behind, and what a save does to the file body.
+ *
+ * The move is the case worth locking: a rename or a user⇄project move once left
+ * the source directory in place, so one skill existed twice and omp could load
+ * whichever it walked into first. A save is the other: the body is read back
+ * with the frontmatter's blank separator removed and written with trailing
+ * whitespace trimmed, so reading and re-saving must be a no-op.
+ *
+ * `PI_CODING_AGENT_DIR` is redirected to a temp dir, so the real
+ * `~/.omp/agent/skills` is never written.
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test';
+import fs from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+
+import { readSkillFile, writeSkillFile } from '@/server/lib/omp/config/skills';
+
+let projectDir = '';
+let agentDir = '';
+let realAgentDir: string | undefined;
+
+beforeAll(() => {
+  projectDir = fs.mkdtempSync(join(tmpdir(), 'ompchamber-skill-project-'));
+  agentDir = fs.mkdtempSync(join(tmpdir(), 'ompchamber-skill-agent-'));
+  realAgentDir = Bun.env.PI_CODING_AGENT_DIR;
+  Bun.env.PI_CODING_AGENT_DIR = agentDir;
+});
+
+afterAll(() => {
+  if (realAgentDir === undefined) delete Bun.env.PI_CODING_AGENT_DIR;
+  else Bun.env.PI_CODING_AGENT_DIR = realAgentDir;
+  fs.rmSync(projectDir, { recursive: true, force: true });
+  fs.rmSync(agentDir, { recursive: true, force: true });
+});
+
+const body = `---
+description: "a skill"
+---
+
+do the thing
+`;
+
+describe('writeSkillFile', () => {
+  test('a project write lands under the workspace .omp/skills', async () => {
+    const { filePath } = await writeSkillFile({
+      scope: 'project',
+      projectDir,
+      name: 'proj-skill',
+      description: 'a skill',
+      hidden: false,
+      body,
+    });
+    expect(filePath).toBe(join(projectDir, '.omp', 'skills', 'proj-skill', 'SKILL.md'));
+    expect(await readSkillFile(filePath)).toEqual({ description: 'a skill', body: body, hidden: false });
+  });
+
+  test('re-saving what was read does not grow the file', async () => {
+    const filePath = join(projectDir, '.omp', 'skills', 'proj-skill', 'SKILL.md');
+    const first = fs.readFileSync(filePath, 'utf8');
+    const parsed = await readSkillFile(filePath);
+    await writeSkillFile({
+      scope: 'project',
+      projectDir,
+      name: 'proj-skill',
+      description: parsed!.description,
+      hidden: parsed!.hidden,
+      body: parsed!.body,
+    });
+    expect(fs.readFileSync(filePath, 'utf8')).toBe(first);
+  });
+
+  test('a move between scopes removes the source, leaving one skill', async () => {
+    const moved = await writeSkillFile({
+      scope: 'user',
+      projectDir,
+      previousDir: join(projectDir, '.omp', 'skills', 'proj-skill'),
+      name: 'proj-skill',
+      description: 'a skill',
+      hidden: false,
+      body,
+    });
+    expect(moved.filePath).toBe(join(agentDir, 'skills', 'proj-skill', 'SKILL.md'));
+    expect(fs.existsSync(join(projectDir, '.omp', 'skills', 'proj-skill'))).toBe(false);
+    expect(fs.existsSync(moved.filePath)).toBe(true);
+  });
+
+  test('a project write with no workspace is refused', () => {
+    expect(writeSkillFile({ scope: 'project', name: 'lost', description: 'd', hidden: false, body: 'b' }))
+      .rejects.toThrow('workspace root is required to write a project skill');
+  });
+
+  test('a name that is not a single directory is refused', () => {
+    expect(writeSkillFile({ scope: 'project', projectDir, name: '../escape', description: 'd', hidden: false, body: 'b' }))
+      .rejects.toThrow('path separator');
+  });
+});