sh3-core 0.7.5 → 0.8.0

package/dist/shell-shard/modes/registry.test.js

@@ -0,0 +1,35 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { ShellModeRegistry } from './registry';
+const dev = { id: 'dev', label: 'Dev', requiresRole: 'admin', transport: 'ws', autoRelocate: false };
+const user = { id: 'user', label: 'User', transport: 'none', autoRelocate: true };
+const ssh = { id: 'ssh', label: 'SSH', requiresRole: 'admin', transport: 'custom', autoRelocate: false };
+describe('ShellModeRegistry', () => {
+    let reg;
+    beforeEach(() => {
+        reg = new ShellModeRegistry();
+    });
+    it('registers and retrieves modes', () => {
+        reg.register(dev);
+        expect(reg.get('dev')).toEqual(dev);
+    });
+    it('list(user) excludes admin-only modes', () => {
+        reg.register(dev);
+        reg.register(user);
+        reg.register(ssh);
+        const ids = reg.list('user').map((m) => m.id);
+        expect(ids).toEqual(['user']);
+    });
+    it('list(admin) includes all modes', () => {
+        reg.register(dev);
+        reg.register(user);
+        reg.register(ssh);
+        const ids = reg.list('admin').map((m) => m.id).sort();
+        expect(ids).toEqual(['dev', 'ssh', 'user']);
+    });
+    it('re-registering same id replaces the mode', () => {
+        var _a;
+        reg.register(dev);
+        reg.register(Object.assign(Object.assign({}, dev), { label: 'Dev+' }));
+        expect((_a = reg.get('dev')) === null || _a === void 0 ? void 0 : _a.label).toBe('Dev+');
+    });
+});

package/dist/shell-shard/modes/types.d.ts

@@ -0,0 +1,8 @@
+export type ShellRole = 'admin' | 'user';
+export interface ShellMode {
+    id: string;
+    label: string;
+    requiresRole?: 'admin';
+    transport: 'ws' | 'none' | 'custom';
+    autoRelocate: boolean;
+}

package/dist/shell-shard/modes/types.js

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/protocol.d.ts

@@ -23,6 +23,12 @@ export type ClientMessage =
 /** Ask the server for its current cwd. */
  | {
     t: 'cwd-query';
+}
+/** Push a cwd change from the frontend (docs tree, file explorer, etc.).
+ *  Server resolves `path` relative to current cwd, validates, broadcasts. */
+ | {
+    t: 'setCwd';
+    path: string;
 };
 export type ServerMessage = 
 /** Sent once on successful attach, immediately after hello. */

package/dist/shell-shard/shellShard.svelte.js

@@ -119,12 +119,16 @@ export const shellShard = {
         const shell = makeShellApi(ctx);
         const factory = {
             mount(container, _context) {
+                var _a;
                 const proto = typeof location !== 'undefined' && location.protocol === 'https:' ? 'wss' : 'ws';
                 const host = typeof location !== 'undefined' ? location.host : 'localhost';
                 const wsUrl = `${proto}://${host}/api/shell/session`;
+                const user = getUser();
+                const userId = (_a = user === null || user === void 0 ? void 0 : user.id) !== null && _a !== void 0 ? _a : 'guest';
+                const role = isAdmin() ? 'admin' : 'user';
                 const instance = mount(Terminal, {
                     target: container,
-                    props: { shell, wsUrl },
+                    props: { shell, wsUrl, userId, role },
                 });
                 return {
                     unmount() {

package/dist/shell-shard/tenant-fs-client.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Client for /api/fs/*. Read-only today.
+ * Shared across all shell modes so verb implementations stay mode-agnostic.
+ */
+export interface FsEntry {
+    name: string;
+    kind: 'file' | 'dir';
+    size: number;
+    mtime: number;
+}
+export interface FsStat {
+    name: string;
+    kind: 'file' | 'dir';
+    size: number;
+    mtime: number;
+}
+export declare class TenantFsClient {
+    #private;
+    private readonly base;
+    constructor(base?: string);
+    list(path: string): Promise<FsEntry[]>;
+    stat(path: string): Promise<FsStat>;
+    read(path: string): Promise<string>;
+}

package/dist/shell-shard/tenant-fs-client.js

@@ -0,0 +1,44 @@
+/**
+ * Client for /api/fs/*. Read-only today.
+ * Shared across all shell modes so verb implementations stay mode-agnostic.
+ */
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _TenantFsClient_instances, _TenantFsClient_get;
+export class TenantFsClient {
+    constructor(base = '') {
+        _TenantFsClient_instances.add(this);
+        this.base = base;
+    }
+    async list(path) {
+        const res = await __classPrivateFieldGet(this, _TenantFsClient_instances, "m", _TenantFsClient_get).call(this, '/api/fs/list', path);
+        const body = await res.json();
+        return body.entries;
+    }
+    async stat(path) {
+        const res = await __classPrivateFieldGet(this, _TenantFsClient_instances, "m", _TenantFsClient_get).call(this, '/api/fs/stat', path);
+        return await res.json();
+    }
+    async read(path) {
+        const res = await __classPrivateFieldGet(this, _TenantFsClient_instances, "m", _TenantFsClient_get).call(this, '/api/fs/read', path);
+        return await res.text();
+    }
+}
+_TenantFsClient_instances = new WeakSet(), _TenantFsClient_get = async function _TenantFsClient_get(route, path) {
+    const url = `${this.base}${route}?path=${encodeURIComponent(path)}`;
+    const res = await fetch(url, { credentials: 'include' });
+    if (!res.ok) {
+        let msg = `HTTP ${res.status}`;
+        try {
+            const j = await res.json();
+            if (j.error)
+                msg = j.error;
+        }
+        catch ( /* non-json body */_a) { /* non-json body */ }
+        throw new Error(msg);
+    }
+    return res;
+};

package/dist/shell-shard/tenant-fs-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/tenant-fs-client.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { TenantFsClient } from './tenant-fs-client';
+beforeEach(() => {
+    vi.restoreAllMocks();
+});
+function mockFetchJson(status, body) {
+    globalThis.fetch = vi.fn(async () => new Response(JSON.stringify(body), {
+        status,
+        headers: { 'content-type': 'application/json' },
+    }));
+}
+describe('TenantFsClient.list', () => {
+    it('GETs /api/fs/list with the encoded path', async () => {
+        const calls = [];
+        globalThis.fetch = vi.fn(async (url) => {
+            calls.push(String(url));
+            return new Response(JSON.stringify({ entries: [{ name: 'a', kind: 'file', size: 1, mtime: 0 }] }), { status: 200 });
+        });
+        const c = new TenantFsClient();
+        const entries = await c.list('sub dir');
+        expect(calls[0]).toContain('/api/fs/list?path=sub%20dir');
+        expect(entries).toHaveLength(1);
+    });
+    it('throws on non-2xx', async () => {
+        mockFetchJson(403, { error: 'forbidden' });
+        const c = new TenantFsClient();
+        await expect(c.list('..')).rejects.toThrow(/forbidden/);
+    });
+});
+describe('TenantFsClient.stat', () => {
+    it('returns kind and size', async () => {
+        mockFetchJson(200, { name: 'a.txt', kind: 'file', size: 5, mtime: 0 });
+        const c = new TenantFsClient();
+        const s = await c.stat('a.txt');
+        expect(s).toMatchObject({ kind: 'file', size: 5 });
+    });
+});
+describe('TenantFsClient.read', () => {
+    it('returns body text on 200', async () => {
+        globalThis.fetch = vi.fn(async () => new Response('hello', { status: 200 }));
+        const c = new TenantFsClient();
+        expect(await c.read('a.txt')).toBe('hello');
+    });
+    it('throws structured error on 413', async () => {
+        mockFetchJson(413, { error: 'file too large' });
+        const c = new TenantFsClient();
+        await expect(c.read('big.bin')).rejects.toThrow(/too large/);
+    });
+});

package/dist/shell-shard/terminal-dispatch.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/terminal-dispatch.test.js

@@ -0,0 +1,53 @@
+import { describe, it, expect, vi } from 'vitest';
+import { makeDispatch } from './dispatch';
+function scaffold(modeId) {
+    const sent = [];
+    const pushed = [];
+    const mode = modeId === 'dev'
+        ? { id: 'dev', label: 'Dev', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }
+        : { id: 'user', label: 'User', transport: 'none', autoRelocate: true };
+    const scrollback = { push: (e) => pushed.push(e) };
+    const session = {
+        history: { push: vi.fn() },
+        send: (m) => sent.push(m),
+        cwd: '/',
+    };
+    const fs = {};
+    const shell = {};
+    const resolver = {
+        resolve: (line) => line.startsWith('pwd')
+            ? { kind: 'local', verb: { name: 'pwd', run: async () => { } }, args: [], line }
+            : { kind: 'forward', line },
+    };
+    const dispatch = makeDispatch({
+        mode: () => mode,
+        resolver,
+        scrollback,
+        session,
+        shell,
+        fs,
+        cwd: () => '/',
+    });
+    return { dispatch, sent, pushed };
+}
+describe('dispatch — user mode', () => {
+    it('unknown verbs print error, do not send', async () => {
+        const { dispatch, sent, pushed } = scaffold('user');
+        await dispatch('foo');
+        expect(sent).toEqual([]);
+        expect(pushed.some((e) => e.kind === 'status' && /unknown verb/.test(e.text))).toBe(true);
+    });
+    it('$ escape prints error', async () => {
+        const { dispatch, sent, pushed } = scaffold('user');
+        await dispatch('$ ls');
+        expect(sent).toEqual([]);
+        expect(pushed.some((e) => e.kind === 'status' && /server shell not available/.test(e.text))).toBe(true);
+    });
+});
+describe('dispatch — dev mode', () => {
+    it('forwards unknown verbs to server', async () => {
+        const { dispatch, sent } = scaffold('dev');
+        await dispatch('foo');
+        expect(sent.some((m) => m.t === 'submit' && m.line === 'foo')).toBe(true);
+    });
+});

package/dist/shell-shard/toolbar/Toolbar.svelte

@@ -0,0 +1,62 @@
+<script lang="ts">
+  import type { ToolbarSlotRegistry, ShellSlotCtx } from './slots';
+
+  interface Props {
+    registry: ToolbarSlotRegistry;
+    ctx: ShellSlotCtx;
+    expanded: boolean;
+    onToggle: () => void;
+    slotProps?: Record<string, Record<string, unknown>>;
+  }
+
+  let { registry, ctx, expanded, onToggle, slotProps = {} }: Props = $props();
+
+  let slots = $derived(registry.list(ctx));
+</script>
+
+<div class="toolbar" class:collapsed={!expanded}>
+  <button class="toolbar-toggle" onclick={onToggle} title={expanded ? 'Collapse toolbar' : 'Expand toolbar'}>
+    {expanded ? '▲' : '▼'}
+  </button>
+  {#if expanded}
+    <div class="toolbar-slots">
+      {#each slots as s (s.id)}
+        {@const Slot = s.component}
+        <Slot {...(slotProps[s.id] ?? {})} />
+      {/each}
+    </div>
+  {/if}
+</div>
+
+<style>
+  .toolbar {
+    display: flex;
+    align-items: center;
+    gap: 6px;
+    padding: 2px 6px;
+    background: var(--shell-toolbar-bg, #1a1a1a);
+    border-bottom: 1px solid var(--shell-border, #333);
+    flex-shrink: 0;
+    min-height: 24px;
+  }
+
+  .toolbar-toggle {
+    background: none;
+    border: none;
+    color: var(--shell-fg-dim, #888);
+    cursor: pointer;
+    font-size: 0.7em;
+    padding: 0 2px;
+    line-height: 1;
+  }
+
+  .toolbar-toggle:hover {
+    color: var(--shell-fg, #ddd);
+  }
+
+  .toolbar-slots {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+  }
+</style>

package/dist/shell-shard/toolbar/Toolbar.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { ToolbarSlotRegistry, ShellSlotCtx } from './slots';
+interface Props {
+    registry: ToolbarSlotRegistry;
+    ctx: ShellSlotCtx;
+    expanded: boolean;
+    onToggle: () => void;
+    slotProps?: Record<string, Record<string, unknown>>;
+}
+declare const Toolbar: import("svelte").Component<Props, {}, "">;
+type Toolbar = ReturnType<typeof Toolbar>;
+export default Toolbar;

package/dist/shell-shard/toolbar/slots/FocusLockSlot.svelte

@@ -0,0 +1,28 @@
+<script lang="ts">
+  interface Props {
+    locked: boolean;
+    onToggle: () => void;
+  }
+
+  let { locked, onToggle }: Props = $props();
+</script>
+
+<button class="focus-lock-btn" onclick={onToggle} title={locked ? 'Unlock focus' : 'Lock focus'}>
+  {locked ? '🔒' : '🔓'}
+</button>
+
+<style>
+  .focus-lock-btn {
+    background: none;
+    border: 1px solid var(--shell-border, #444);
+    border-radius: 3px;
+    cursor: pointer;
+    padding: 2px 5px;
+    font-size: 0.9em;
+    line-height: 1;
+  }
+
+  .focus-lock-btn:hover {
+    background: var(--shell-hover, #222);
+  }
+</style>

package/dist/shell-shard/toolbar/slots/FocusLockSlot.svelte.d.ts

@@ -0,0 +1,7 @@
+interface Props {
+    locked: boolean;
+    onToggle: () => void;
+}
+declare const FocusLockSlot: import("svelte").Component<Props, {}, "">;
+type FocusLockSlot = ReturnType<typeof FocusLockSlot>;
+export default FocusLockSlot;

package/dist/shell-shard/toolbar/slots/ModeSlot.svelte

@@ -0,0 +1,102 @@
+<script lang="ts">
+  import type { ShellMode, ShellRole } from '../../modes/types';
+  import type { ShellModeRegistry } from '../../modes/registry';
+
+  interface Props {
+    mode: ShellMode;
+    role: ShellRole;
+    registry: ShellModeRegistry;
+    onSelect: (id: string) => void;
+  }
+
+  let { mode, role, registry, onSelect }: Props = $props();
+
+  let open = $state(false);
+
+  function select(id: string) {
+    open = false;
+    onSelect(id);
+  }
+</script>
+
+{#if role === 'admin'}
+  <div class="mode-slot">
+    <button class="mode-btn" onclick={() => (open = !open)}>
+      {mode.label} ▾
+    </button>
+    {#if open}
+      <ul class="mode-menu" role="menu">
+        {#each registry.list(role) as m (m.id)}
+          <li role="menuitem">
+            <button
+              class="mode-option"
+              class:active={m.id === mode.id}
+              onclick={() => select(m.id)}
+            >
+              {m.label}
+            </button>
+          </li>
+        {/each}
+      </ul>
+    {/if}
+  </div>
+{:else}
+  <span class="mode-label">{mode.label}</span>
+{/if}
+
+<style>
+  .mode-slot {
+    position: relative;
+    display: inline-block;
+  }
+
+  .mode-btn {
+    background: none;
+    border: 1px solid var(--shell-border, #444);
+    color: var(--shell-fg, #ddd);
+    padding: 2px 6px;
+    border-radius: 3px;
+    cursor: pointer;
+    font-size: 0.85em;
+  }
+
+  .mode-btn:hover {
+    background: var(--shell-hover, #222);
+  }
+
+  .mode-menu {
+    position: absolute;
+    top: 100%;
+    left: 0;
+    margin: 2px 0 0;
+    padding: 0;
+    list-style: none;
+    background: var(--shell-bg, #111);
+    border: 1px solid var(--shell-border, #444);
+    border-radius: 3px;
+    z-index: 100;
+    min-width: 100%;
+  }
+
+  .mode-option {
+    display: block;
+    width: 100%;
+    background: none;
+    border: none;
+    color: var(--shell-fg, #ddd);
+    padding: 4px 10px;
+    text-align: left;
+    cursor: pointer;
+    font-size: 0.85em;
+  }
+
+  .mode-option:hover,
+  .mode-option.active {
+    background: var(--shell-hover, #222);
+  }
+
+  .mode-label {
+    font-size: 0.85em;
+    color: var(--shell-fg-dim, #888);
+  }
+</style>

package/dist/shell-shard/toolbar/slots/ModeSlot.svelte.d.ts

@@ -0,0 +1,11 @@
+import type { ShellMode, ShellRole } from '../../modes/types';
+import type { ShellModeRegistry } from '../../modes/registry';
+interface Props {
+    mode: ShellMode;
+    role: ShellRole;
+    registry: ShellModeRegistry;
+    onSelect: (id: string) => void;
+}
+declare const ModeSlot: import("svelte").Component<Props, {}, "">;
+type ModeSlot = ReturnType<typeof ModeSlot>;
+export default ModeSlot;

package/dist/shell-shard/toolbar/slots/TargetShardSlot.svelte

@@ -0,0 +1,17 @@
+<script lang="ts">
+  interface Props {
+    target: string | null;
+  }
+
+  let { target }: Props = $props();
+</script>
+
+<span class="target-shard" title="Target shard">→ {target ?? '—'}</span>
+
+<style>
+  .target-shard {
+    font-size: 0.85em;
+    color: var(--shell-fg-dim, #888);
+    font-family: monospace;
+  }
+</style>

package/dist/shell-shard/toolbar/slots/TargetShardSlot.svelte.d.ts

@@ -0,0 +1,6 @@
+interface Props {
+    target: string | null;
+}
+declare const TargetShardSlot: import("svelte").Component<Props, {}, "">;
+type TargetShardSlot = ReturnType<typeof TargetShardSlot>;
+export default TargetShardSlot;

package/dist/shell-shard/toolbar/slots.d.ts

@@ -0,0 +1,17 @@
+import type { Component } from 'svelte';
+import type { ShellMode, ShellRole } from '../modes/types';
+export interface ShellSlotCtx {
+    mode: ShellMode;
+    role: ShellRole;
+}
+export interface ToolbarSlot {
+    id: string;
+    order: number;
+    visible(ctx: ShellSlotCtx): boolean;
+    component: Component<any>;
+}
+export declare class ToolbarSlotRegistry {
+    #private;
+    register(slot: ToolbarSlot): void;
+    list(ctx: ShellSlotCtx): ToolbarSlot[];
+}

package/dist/shell-shard/toolbar/slots.js

@@ -0,0 +1,26 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _ToolbarSlotRegistry_slots;
+export class ToolbarSlotRegistry {
+    constructor() {
+        _ToolbarSlotRegistry_slots.set(this, []);
+    }
+    register(slot) {
+        __classPrivateFieldSet(this, _ToolbarSlotRegistry_slots, __classPrivateFieldGet(this, _ToolbarSlotRegistry_slots, "f").filter((s) => s.id !== slot.id).concat(slot), "f");
+    }
+    list(ctx) {
+        return __classPrivateFieldGet(this, _ToolbarSlotRegistry_slots, "f")
+            .filter((s) => s.visible(ctx))
+            .sort((a, b) => a.order - b.order);
+    }
+}
+_ToolbarSlotRegistry_slots = new WeakMap();

package/dist/shell-shard/toolbar/slots.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/shell-shard/toolbar/slots.test.js

@@ -0,0 +1,28 @@
+import { describe, it, expect } from 'vitest';
+import { ToolbarSlotRegistry } from './slots';
+const A = { id: 'a', order: 20, visible: () => true, component: {} };
+const B = { id: 'b', order: 10, visible: () => true, component: {} };
+const C = { id: 'c', order: 30, visible: (ctx) => ctx.mode.id === 'user', component: {} };
+const userCtx = { mode: { id: 'user', label: 'User', transport: 'none', autoRelocate: true }, role: 'user' };
+const devCtx = { mode: { id: 'dev', label: 'Dev', transport: 'ws', autoRelocate: false, requiresRole: 'admin' }, role: 'admin' };
+describe('ToolbarSlotRegistry', () => {
+    it('lists visible slots in order', () => {
+        const r = new ToolbarSlotRegistry();
+        r.register(A);
+        r.register(B);
+        r.register(C);
+        expect(r.list(userCtx).map((s) => s.id)).toEqual(['b', 'a', 'c']);
+    });
+    it('filters by visible', () => {
+        const r = new ToolbarSlotRegistry();
+        r.register(A);
+        r.register(C);
+        expect(r.list(devCtx).map((s) => s.id)).toEqual(['a']);
+    });
+    it('re-registering by id replaces', () => {
+        const r = new ToolbarSlotRegistry();
+        r.register(A);
+        r.register(Object.assign(Object.assign({}, A), { order: 99 }));
+        expect(r.list(userCtx)[0].order).toBe(99);
+    });
+});

package/dist/shell-shard/verbs/cat.d.ts

@@ -0,0 +1,2 @@
+import type { Verb } from '../../verbs/types';
+export declare const catVerb: Verb;

package/dist/shell-shard/verbs/cat.js

@@ -0,0 +1,34 @@
+export const catVerb = {
+    name: 'cat',
+    summary: 'Read a file into the scrollback.',
+    async run(ctx, args) {
+        if (args.length === 0) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: 'cat: missing file argument',
+                level: 'error',
+                ts: Date.now(),
+            });
+            return;
+        }
+        const path = args[0];
+        const target = ctx.session.cwd ? `${ctx.session.cwd}/${path}` : path;
+        try {
+            const text = await ctx.fs.read(target);
+            ctx.scrollback.push({
+                kind: 'text',
+                stream: 'stdout',
+                chunks: [text],
+                ts: Date.now(),
+            });
+        }
+        catch (err) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: `cat: ${err.message}`,
+                level: 'error',
+                ts: Date.now(),
+            });
+        }
+    },
+};

package/dist/shell-shard/verbs/cd.test.d.ts

@@ -0,0 +1 @@
+export {};