@cmetech/otto 1.1.0 → 1.2.4

package/src/resources/extensions/coworker-scratchpad/extension-manifest.json

@@ -0,0 +1,13 @@
+{
+  "id": "coworker-scratchpad",
+  "name": "Co-worker Scratchpad",
+  "version": "1.0.0",
+  "description": "Persistent TypeScript scratchpad kernel: /sp slash commands and cw_scratchpad tool with MIME bundle responses",
+  "tier": "bundled",
+  "requires": { "platform": ">=2.29.0" },
+  "provides": {
+    "tools": ["cw_scratchpad"],
+    "commands": ["sp"],
+    "hooks": ["session_start", "session_shutdown"]
+  }
+}

package/src/resources/extensions/coworker-scratchpad/format-age.test.ts

@@ -0,0 +1,30 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+import { formatRelativeAge } from './format-age.js';
+
+describe('formatRelativeAge', () => {
+  it('returns "active" for ages under 30s', () => {
+    assert.equal(formatRelativeAge(0), 'active');
+    assert.equal(formatRelativeAge(15_000), 'active');
+    assert.equal(formatRelativeAge(29_999), 'active');
+  });
+
+  it('returns "idle Xm" for ages 30s–1h (floored minutes)', () => {
+    assert.equal(formatRelativeAge(30_000), 'idle 0m');
+    assert.equal(formatRelativeAge(60_000), 'idle 1m');
+    assert.equal(formatRelativeAge(30 * 60_000), 'idle 30m');
+    assert.equal(formatRelativeAge(59 * 60_000 + 59_000), 'idle 59m');
+  });
+
+  it('returns "idle Xh" for ages 1h–24h (floored hours)', () => {
+    assert.equal(formatRelativeAge(60 * 60_000), 'idle 1h');
+    assert.equal(formatRelativeAge(2 * 60 * 60_000 + 30 * 60_000), 'idle 2h');
+    assert.equal(formatRelativeAge(23 * 60 * 60_000 + 59 * 60_000), 'idle 23h');
+  });
+
+  it('returns "idle Xd" for ages 24h+ (floored days)', () => {
+    assert.equal(formatRelativeAge(24 * 60 * 60_000), 'idle 1d');
+    assert.equal(formatRelativeAge(7 * 24 * 60 * 60_000), 'idle 7d');
+    assert.equal(formatRelativeAge(30 * 24 * 60 * 60_000 + 5 * 60 * 60_000), 'idle 30d');
+  });
+});

package/src/resources/extensions/coworker-scratchpad/format-age.ts

@@ -0,0 +1,6 @@
+export function formatRelativeAge(ageMs: number): string {
+  if (ageMs < 30_000) return 'active';
+  if (ageMs < 60 * 60_000) return `idle ${Math.floor(ageMs / 60_000)}m`;
+  if (ageMs < 24 * 60 * 60_000) return `idle ${Math.floor(ageMs / (60 * 60_000))}h`;
+  return `idle ${Math.floor(ageMs / (24 * 60 * 60_000))}d`;
+}

package/src/resources/extensions/coworker-scratchpad/helpers.test.ts

@@ -0,0 +1,93 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SCRATCHPAD_NAME_REGEX, validateName, readCellsJsonl, readPersistedLeaf } from './helpers.js';
+
+describe('SCRATCHPAD_NAME_REGEX + validateName', () => {
+  it('accepts simple letter-led names', () => {
+    for (const ok of ['default', 'p1', 'p1-1234', 'investigation_q4', 'A', 'rca-server-01']) {
+      assert.equal(SCRATCHPAD_NAME_REGEX.test(ok), true, `should accept: ${ok}`);
+      assert.doesNotThrow(() => validateName(ok));
+    }
+  });
+
+  it('rejects digit-led, separator-led, empty, too-long, and traversal characters', () => {
+    for (const bad of ['', '1abc', '-foo', '_foo', 'foo.bar', 'foo/bar', '..', 'a/b', 'a'.repeat(65)]) {
+      assert.equal(SCRATCHPAD_NAME_REGEX.test(bad), false, `should reject: ${JSON.stringify(bad)}`);
+      assert.throws(() => validateName(bad), /invalid scratchpad name/);
+    }
+  });
+});
+
+describe('readCellsJsonl', () => {
+  let dir: string;
+  beforeEach(async () => {
+    dir = await mkdtemp(join(tmpdir(), 'cells-r-'));
+  });
+  afterEach(async () => {
+    await rm(dir, { recursive: true, force: true });
+  });
+
+  it('returns empty result when cells.jsonl does not exist', () => {
+    const r = readCellsJsonl(dir);
+    assert.deepEqual(r, { cells: [], total_cells: 0 });
+  });
+
+  it('reads schema-header + entries; ignores trailing corrupt line', async () => {
+    const lines = [
+      JSON.stringify({ type: 'header', version: 1 }),
+      JSON.stringify({ id: 1, parentId: null, code: 'return 1;', ok: true, value: 1, stdout: '', ts: '2026-05-31T00:00:00.000Z' }),
+      JSON.stringify({ id: 2, parentId: 1, code: 'return 2;', ok: true, value: 2, stdout: '', ts: '2026-05-31T00:00:01.000Z' }),
+      '{ not-json',
+    ];
+    await writeFile(join(dir, 'cells.jsonl'), lines.join('\n') + '\n');
+    const r = readCellsJsonl(dir);
+    assert.equal(r.total_cells, 2);
+    assert.equal(r.cells[0].id, 1);
+    assert.equal(r.cells[1].id, 2);
+    assert.equal(r.cells[1].parentId, 1);
+  });
+
+  it('returns cells in chronological order (file order)', async () => {
+    const lines = [
+      JSON.stringify({ type: 'header', version: 1 }),
+      JSON.stringify({ id: 1, parentId: null, code: 'a', ok: true, value: 'a', stdout: '', ts: 't1' }),
+      JSON.stringify({ id: 2, parentId: 1, code: 'b', ok: true, value: 'b', stdout: '', ts: 't2' }),
+      JSON.stringify({ id: 3, parentId: 2, code: 'c', ok: false, error: { name: 'E', message: 'm' }, stdout: '', ts: 't3' }),
+    ];
+    await writeFile(join(dir, 'cells.jsonl'), lines.join('\n') + '\n');
+    const r = readCellsJsonl(dir);
+    assert.equal(r.cells.length, 3);
+    assert.equal(r.cells[2].ok, false);
+    assert.equal(r.cells[2].error?.message, 'm');
+  });
+});
+
+describe('readPersistedLeaf', () => {
+  let dir: string;
+  beforeEach(async () => { dir = await mkdtemp(join(tmpdir(), 'rpl-')); });
+  afterEach(async () => { await rm(dir, { recursive: true, force: true }); });
+
+  it('returns null when meta.json is missing', () => {
+    assert.equal(readPersistedLeaf(join(dir, 'meta.json')), null);
+  });
+
+  it('returns null when cell_leaf_id is absent or null', async () => {
+    await writeFile(join(dir, 'meta.json'), JSON.stringify({ name: 'x' }));
+    assert.equal(readPersistedLeaf(join(dir, 'meta.json')), null);
+    await writeFile(join(dir, 'meta.json'), JSON.stringify({ name: 'x', cell_leaf_id: null }));
+    assert.equal(readPersistedLeaf(join(dir, 'meta.json')), null);
+  });
+
+  it('returns the cell_leaf_id when present as a number', async () => {
+    await writeFile(join(dir, 'meta.json'), JSON.stringify({ name: 'x', cell_leaf_id: 7 }));
+    assert.equal(readPersistedLeaf(join(dir, 'meta.json')), 7);
+  });
+
+  it('returns null on corrupt meta', async () => {
+    await writeFile(join(dir, 'meta.json'), '{not json');
+    assert.equal(readPersistedLeaf(join(dir, 'meta.json')), null);
+  });
+});

package/src/resources/extensions/coworker-scratchpad/helpers.ts

@@ -0,0 +1,42 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import type { CellEntry } from '@otto/coworker-scratchpad';
+
+export const SCRATCHPAD_NAME_REGEX = /^[a-zA-Z][a-zA-Z0-9_-]{0,63}$/;
+
+export function validateName(name: string): void {
+  if (!SCRATCHPAD_NAME_REGEX.test(name)) {
+    throw new Error(`invalid scratchpad name: ${JSON.stringify(name)} (must match ${SCRATCHPAD_NAME_REGEX})`);
+  }
+}
+
+export interface CellsJsonlRead {
+  cells: CellEntry[];
+  total_cells: number;
+}
+
+export function readCellsJsonl(dir: string): CellsJsonlRead {
+  const path = join(dir, 'cells.jsonl');
+  if (!existsSync(path)) return { cells: [], total_cells: 0 };
+  const cells: CellEntry[] = [];
+  for (const line of readFileSync(path, 'utf8').split('\n')) {
+    if (!line.trim()) continue;
+    try {
+      const obj = JSON.parse(line) as { id?: unknown };
+      if (typeof obj.id === 'number') cells.push(obj as CellEntry);
+    } catch {
+      // header line or trailing corrupt line -> skip (same tolerance as CellArchive.scan)
+    }
+  }
+  return { cells, total_cells: cells.length };
+}
+
+export function readPersistedLeaf(metaPath: string): number | null {
+  if (!existsSync(metaPath)) return null;
+  try {
+    const meta = JSON.parse(readFileSync(metaPath, 'utf8')) as { cell_leaf_id?: unknown };
+    return typeof meta.cell_leaf_id === 'number' ? meta.cell_leaf_id : null;
+  } catch {
+    return null;
+  }
+}