sh3-core 0.7.5 → 0.8.1

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 {};

package/dist/shell-shard/verbs/cd.test.js

@@ -0,0 +1,56 @@
+import { describe, it, expect } from 'vitest';
+import { cdVerb } from './session';
+function makeCtx(initialCwd, fsStat) {
+    const pushed = [];
+    const session = { cwd: initialCwd };
+    const ctx = {
+        shell: {},
+        scrollback: { push: (e) => pushed.push(e) },
+        session,
+        cwd: initialCwd,
+        fs: {
+            list: async () => [],
+            stat: fsStat,
+            read: async () => '',
+        },
+        dispatch: async () => { },
+    };
+    return { ctx, session, pushed };
+}
+describe('cd verb', () => {
+    it('updates session.cwd on successful dir stat', async () => {
+        const { ctx, session } = makeCtx('', async (_path) => ({
+            name: 'projects',
+            kind: 'dir',
+            size: 0,
+            mtime: 0,
+        }));
+        await cdVerb.run(ctx, ['projects']);
+        expect(session.cwd).toBe('projects');
+    });
+    it('pushes error when target is a file, not a directory', async () => {
+        const { ctx, session, pushed } = makeCtx('', async (_path) => ({
+            name: 'readme.txt',
+            kind: 'file',
+            size: 100,
+            mtime: 0,
+        }));
+        await cdVerb.run(ctx, ['readme.txt']);
+        expect(session.cwd).toBe('');
+        const entry = pushed[0];
+        expect(entry.kind).toBe('status');
+        expect(entry.level).toBe('error');
+        expect(entry.text).toMatch(/not a directory/);
+    });
+    it('pushes error when fs.stat throws', async () => {
+        const { ctx, session, pushed } = makeCtx('', async (_path) => {
+            throw new Error('no such file');
+        });
+        await cdVerb.run(ctx, ['nonexistent']);
+        expect(session.cwd).toBe('');
+        const entry = pushed[0];
+        expect(entry.kind).toBe('status');
+        expect(entry.level).toBe('error');
+        expect(entry.text).toMatch(/no such file/);
+    });
+});

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

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

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

@@ -0,0 +1,14 @@
+import EnvTable from '../rich/EnvTable.svelte';
+export const envVerb = {
+    name: 'env',
+    summary: 'Show the session environment.',
+    async run(ctx) {
+        const env = ctx.session.env;
+        ctx.scrollback.push({
+            kind: 'rich',
+            component: EnvTable,
+            props: { data: { env } },
+            ts: Date.now(),
+        });
+    },
+};

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

@@ -7,9 +7,12 @@ import { clearVerb } from './clear';
 import { historyVerb } from './history';
 import { appsVerb, appVerb } from './apps';
 import { shardsVerb } from './shards';
-import { viewsVerb, openVerb, closeVerb } from './views';
+import { viewsVerb, openVerb, closeVerb, popoutVerb, dockVerb } from './views';
 import { zonesVerb, zoneVerb } from './zones';
-import { pwdVerb, cdVerb, envVerb, whoamiVerb } from './session';
+import { pwdVerb, cdVerb, whoamiVerb } from './session';
+import { envVerb } from './env';
+import { lsVerb } from './ls';
+import { catVerb } from './cat';
 export function registerV1Verbs(ctx) {
     ctx.registerVerb(makeHelpVerb());
     ctx.registerVerb(clearVerb);
@@ -20,10 +23,14 @@ export function registerV1Verbs(ctx) {
     ctx.registerVerb(viewsVerb);
     ctx.registerVerb(openVerb);
     ctx.registerVerb(closeVerb);
+    ctx.registerVerb(popoutVerb);
+    ctx.registerVerb(dockVerb);
     ctx.registerVerb(zonesVerb);
     ctx.registerVerb(zoneVerb);
     ctx.registerVerb(pwdVerb);
     ctx.registerVerb(cdVerb);
     ctx.registerVerb(envVerb);
     ctx.registerVerb(whoamiVerb);
+    ctx.registerVerb(lsVerb);
+    ctx.registerVerb(catVerb);
 }

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

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

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

@@ -0,0 +1,29 @@
+export const lsVerb = {
+    name: 'ls',
+    summary: 'List the current directory.',
+    async run(ctx) {
+        let entries;
+        try {
+            entries = await ctx.fs.list(ctx.session.cwd);
+        }
+        catch (err) {
+            ctx.scrollback.push({
+                kind: 'status',
+                text: `ls: ${err.message}`,
+                level: 'error',
+                ts: Date.now(),
+            });
+            return;
+        }
+        const lines = entries
+            .sort((a, b) => a.name.localeCompare(b.name))
+            .map((e) => (e.kind === 'dir' ? `${e.name}/` : e.name))
+            .join('\n');
+        ctx.scrollback.push({
+            kind: 'text',
+            stream: 'stdout',
+            chunks: [lines || '(empty)'],
+            ts: Date.now(),
+        });
+    },
+};

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

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

package/dist/shell-shard/verbs/ls.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest';
+import { lsVerb } from './ls';
+function makeCtx(cwd, fsList) {
+    const pushed = [];
+    const ctx = {
+        shell: {},
+        scrollback: { push: (e) => pushed.push(e) },
+        session: { cwd },
+        cwd,
+        fs: {
+            list: fsList,
+            stat: async () => ({ kind: 'dir', name: '', size: 0, mtime: 0 }),
+            read: async () => '',
+        },
+        dispatch: async () => { },
+    };
+    return { ctx, pushed };
+}
+describe('ls verb', () => {
+    it('lists entries sorted, dirs with trailing slash', async () => {
+        const { ctx, pushed } = makeCtx('', async () => [
+            { name: 'zebra.txt', kind: 'file', size: 1, mtime: 0 },
+            { name: 'apple', kind: 'dir', size: 0, mtime: 0 },
+            { name: 'mango.txt', kind: 'file', size: 2, mtime: 0 },
+        ]);
+        await lsVerb.run(ctx, []);
+        expect(pushed).toHaveLength(1);
+        const entry = pushed[0];
+        expect(entry.kind).toBe('text');
+        expect(entry.chunks[0]).toBe('apple/\nmango.txt\nzebra.txt');
+    });
+    it('shows (empty) for empty directory', async () => {
+        const { ctx, pushed } = makeCtx('', async () => []);
+        await lsVerb.run(ctx, []);
+        const entry = pushed[0];
+        expect(entry.kind).toBe('text');
+        expect(entry.chunks[0]).toBe('(empty)');
+    });
+    it('pushes status error when fs.list throws', async () => {
+        const { ctx, pushed } = makeCtx('', async () => {
+            throw new Error('permission denied');
+        });
+        await lsVerb.run(ctx, []);
+        const entry = pushed[0];
+        expect(entry.kind).toBe('status');
+        expect(entry.level).toBe('error');
+        expect(entry.text).toMatch(/permission denied/);
+    });
+});

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

@@ -1,5 +1,4 @@
 import type { Verb } from '../../verbs/types';
 export declare const pwdVerb: Verb;
 export declare const cdVerb: Verb;
-export declare const envVerb: Verb;
 export declare const whoamiVerb: Verb;

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

@@ -1,18 +1,47 @@
 /*
- * Session verbs: pwd, cd, env, whoami.
+ * Session verbs: pwd, cd, whoami.
  *
- * cd is server-authoritative — the client forwards it as a 'submit' message
- * so ws.ts can intercept and update session.cwd without spawning a process.
+ * cd validates the target path via ctx.fs.stat() then updates session.cwd
+ * locally. The server still owns the authoritative cwd for forwarded
+ * commands, but local verbs track it via session.cwd.
+ *
+ * envVerb lives in env.ts (separate Svelte import).
  */
-import EnvTable from '../rich/EnvTable.svelte';
+// ---------------------------------------------------------------------------
+// Path helpers
+// ---------------------------------------------------------------------------
+function joinRel(cwd, input) {
+    if (input.startsWith('/'))
+        return normalizeRel(input.slice(1));
+    const parts = [...cwd.split('/').filter(Boolean), ...input.split('/')];
+    const stack = [];
+    for (const p of parts) {
+        if (p === '' || p === '.')
+            continue;
+        if (p === '..') {
+            stack.pop();
+            continue;
+        }
+        stack.push(p);
+    }
+    return stack.join('/');
+}
+function normalizeRel(s) {
+    return s.split('/').filter((p) => p && p !== '.').join('/');
+}
+// ---------------------------------------------------------------------------
+// Verbs
+// ---------------------------------------------------------------------------
 export const pwdVerb = {
     name: 'pwd',
-    summary: 'Show the server session cwd.',
+    summary: 'Show the current working directory.',
     async run(ctx) {
+        const rel = ctx.session.cwd || '';
+        const display = rel.startsWith('/') ? rel : `/${rel}`;
         ctx.scrollback.push({
             kind: 'text',
             stream: 'stdout',
-            chunks: [ctx.cwd + '\n'],
+            chunks: [display + '\n'],
             ts: Date.now(),
         });
     },
@@ -22,32 +51,35 @@ export const cdVerb = {
     summary: 'Change the session working directory.',
     async run(ctx, args) {
         var _a;
-        const path = (_a = args[0]) !== null && _a !== void 0 ? _a : '';
-        if (!path) {
+        const target = (_a = args[0]) !== null && _a !== void 0 ? _a : '';
+        if (target === '') {
+            ctx.session.cwd = '';
+            return;
+        }
+        const base = ctx.session.cwd;
+        const candidate = joinRel(base, target);
+        try {
+            const s = await ctx.fs.stat(candidate);
+            if (s.kind !== 'dir') {
+                ctx.scrollback.push({
+                    kind: 'status',
+                    text: `cd: not a directory: ${target}`,
+                    level: 'error',
+                    ts: Date.now(),
+                });
+                return;
+            }
+        }
+        catch (err) {
             ctx.scrollback.push({
                 kind: 'status',
-                text: 'usage: cd <path>',
-                level: 'warn',
+                text: `cd: ${err.message}`,
+                level: 'error',
                 ts: Date.now(),
             });
             return;
         }
-        // cd is server-authoritative. Forward the submit so the server's
-        // dispatcher can intercept it and update session.cwd (see ws.ts).
-        ctx.session.send({ t: 'submit', line: `cd ${path}` });
-    },
-};
-export const envVerb = {
-    name: 'env',
-    summary: 'Show the session environment.',
-    async run(ctx) {
-        const env = ctx.session.env;
-        ctx.scrollback.push({
-            kind: 'rich',
-            component: EnvTable,
-            props: { data: { env } },
-            ts: Date.now(),
-        });
+        ctx.session.cwd = candidate;
     },
 };
 export const whoamiVerb = {

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

@@ -1,4 +1,6 @@
 import type { Verb } from '../../verbs/types';
 export declare const viewsVerb: Verb;
 export declare const openVerb: Verb;
+export declare const popoutVerb: Verb;
+export declare const dockVerb: Verb;
 export declare const closeVerb: Verb;