sh3-core 0.15.1 → 0.15.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sh3-core",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "type": "module",
   "files": [
     "dist"

package/dist/app-appearance/AppAppearanceModal.svelte.d.ts

@@ -1,8 +0,0 @@
-interface Props {
-    appId: string;
-    appLabel: string;
-    close: () => void;
-}
-declare const AppAppearanceModal: import("svelte").Component<Props, {}, "">;
-type AppAppearanceModal = ReturnType<typeof AppAppearanceModal>;
-export default AppAppearanceModal;

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

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

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

@@ -1,35 +0,0 @@
-export const catVerb = {
-    name: 'cat',
-    summary: 'Read a file into the scrollback.',
-    programmatic: true,
-    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.js

@@ -1,56 +0,0 @@
-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/ls.d.ts

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

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

@@ -1,30 +0,0 @@
-export const lsVerb = {
-    name: 'ls',
-    summary: 'List the current directory.',
-    programmatic: true,
-    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.js

@@ -1,49 +0,0 @@
-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,4 +0,0 @@
-import type { Verb } from '../../verbs/types';
-export declare const pwdVerb: Verb;
-export declare const cdVerb: Verb;
-export declare const whoamiVerb: Verb;

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

@@ -1,99 +0,0 @@
-/*
- * Session verbs: pwd, cd, whoami.
- *
- * 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).
- */
-// ---------------------------------------------------------------------------
-// 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 current working directory.',
-    programmatic: true,
-    async run(ctx) {
-        const rel = ctx.session.cwd || '';
-        const display = rel.startsWith('/') ? rel : `/${rel}`;
-        ctx.scrollback.push({
-            kind: 'text',
-            stream: 'stdout',
-            chunks: [display + '\n'],
-            ts: Date.now(),
-        });
-    },
-};
-export const cdVerb = {
-    name: 'cd',
-    summary: 'Change the session working directory.',
-    async run(ctx, args) {
-        var _a;
-        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: `cd: ${err.message}`,
-                level: 'error',
-                ts: Date.now(),
-            });
-            return;
-        }
-        ctx.session.cwd = candidate;
-    },
-};
-export const whoamiVerb = {
-    name: 'whoami',
-    summary: 'Show the current admin user and session info.',
-    programmatic: true,
-    async run(ctx) {
-        const me = ctx.shell.whoAmI();
-        ctx.scrollback.push({
-            kind: 'text',
-            stream: 'stdout',
-            chunks: [`${me.userId}${me.admin ? ' (admin)' : ''}\n`],
-            ts: Date.now(),
-        });
-    },
-};