sh3-core 0.7.5 → 0.8.0

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

@@ -9,7 +9,10 @@ import { appsVerb, appVerb } from './apps';
 import { shardsVerb } from './shards';
 import { viewsVerb, openVerb, closeVerb } 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);
@@ -26,4 +29,6 @@ export function registerV1Verbs(ctx) {
     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/verbs/types.d.ts

@@ -1,5 +1,6 @@
 import type { Scrollback } from '../shell-shard/scrollback.svelte';
 import type { SessionClient } from '../shell-shard/session-client.svelte';
+import type { TenantFsClient } from '../shell-shard/tenant-fs-client';
 export interface ShellApi {
     listApps(): Array<{
         id: string;
@@ -43,6 +44,7 @@ export interface VerbContext {
     scrollback: Scrollback;
     session: SessionClient;
     cwd: string;
+    fs: TenantFsClient;
     /** Invoke another registered verb programmatically (used by rich-entry clicks). */
     dispatch(line: string): Promise<void>;
 }

package/dist/version.d.ts

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export declare const VERSION = "0.7.5";
+export declare const VERSION = "0.8.0";

package/dist/version.js

@@ -1,2 +1,2 @@
 /** Auto-generated from package.json — do not edit manually. */
-export const VERSION = '0.7.5';
+export const VERSION = '0.8.0';

package/package.json

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