@goodandready/dsh-time-machine 0.1.3 → 0.1.4

package/lib/client.js

@@ -104,7 +104,24 @@ window.__ModuleLoader__.load({
       return lang;
     }
 
-    function Timeline({ t }) {
+    function sessionIdOf(ctx) {
+      try {
+        if (!ctx) return '';
+        if (ctx.scope) {
+          if (ctx.scope.session) return String(ctx.scope.session.id || ctx.scope.session.header?.id || '');
+          if (typeof ctx.scope.id === 'string') return ctx.scope.id;
+        }
+        if (ctx.session) return String(ctx.session.id || ctx.session.header?.id || '');
+        if (ctx.get && typeof ctx.get === 'function') {
+          const s = ctx.get('session');
+          if (s) return String(s.id || s.header?.id || '');
+        }
+      } catch {}
+      return '';
+    }
+
+    function Timeline({ t, ctx }) {
+      const sid = sessionIdOf(ctx);
       const [snapshots, setSnapshots] = React.useState([]);
       const [loading, setLoading] = React.useState(false);
       const [label, setLabel] = React.useState('');
@@ -114,17 +131,18 @@ window.__ModuleLoader__.load({
 
       const fetchList = React.useCallback(() => {
         setLoading(true); setErr('');
-        fetch('/dsh-time-machine/snapshots').then(r => r.json()).then(j => {
+        const q = sid ? '?sessionId=' + encodeURIComponent(sid) : '';
+        fetch('/dsh-time-machine/snapshots' + q).then(r => r.json()).then(j => {
           if (j.success) setSnapshots(j.snapshots || []);
           else setErr(j.error || 'load failed');
         }).catch(e => setErr(String(e.message || e))).finally(() => setLoading(false));
-      }, []);
+      }, [sid]);
 
       React.useEffect(() => { fetchList(); }, [fetchList]);
 
       const onCreate = () => {
         setBusy(true); setErr('');
-        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label }) })
+        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label, sessionId: sid }) })
           .then(r => r.json()).then(j => {
             if (!j.success) throw new Error(j.error || 'create failed');
             setLabel(''); fetchList();
@@ -179,6 +197,7 @@ window.__ModuleLoader__.load({
 
     function PluginCard(props) {
       const ctx = props.ctx;
+      const sid = sessionIdOf(ctx);
       const [expanded, setExpanded] = React.useState(false);
       const lang = useLocale(ctx);
       const t = lang === 'ru' ? ru : en;
@@ -225,17 +244,18 @@ window.__ModuleLoader__.load({
 
       const fetchList = React.useCallback(() => {
         setLoading(true); setErr('');
-        fetch('/dsh-time-machine/snapshots').then(r => r.json()).then(j => {
+        const q = sid ? '?sessionId=' + encodeURIComponent(sid) : '';
+        fetch('/dsh-time-machine/snapshots' + q).then(r => r.json()).then(j => {
           if (j.success) setSnapshots(j.snapshots || []);
           else setErr(j.error || 'load failed');
         }).catch(e => setErr(String(e.message || e))).finally(() => setLoading(false));
-      }, []);
+      }, [sid]);
 
       React.useEffect(() => { if (expanded) fetchList(); }, [expanded, fetchList]);
 
       const onCreate = () => {
         setBusy(true); setErr('');
-        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label }) })
+        fetch('/dsh-time-machine/create', { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ label, sessionId: sid }) })
           .then(r => r.json()).then(j => {
             if (!j.success) throw new Error(j.error || 'create failed');
             setLabel(''); fetchList();
@@ -342,31 +362,10 @@ window.__ModuleLoader__.load({
       return React.createElement('div', { className: 'tm-tab' },
         React.createElement('div', { style: { fontSize: 13, fontWeight: 600, color: 'var(--dsw-alias-label-primary)' } }, t.tabTitle),
         React.createElement('div', { style: { fontSize: 12, color: 'var(--dsw-alias-label-secondary)', marginBottom: 4 } }, t.sub),
-        React.createElement(Timeline, { t })
+        React.createElement(Timeline, { t, ctx })
       );
     }
 
-    function registerBetterSidebar(ctx) {
-      const svc = (ctx.get && (()=>{ try{return ctx.get('betterSidebar')}catch{return null}})()) || ctx.betterSidebar;
-      if (!svc || typeof svc.registerTab !== 'function') return;
-      try {
-        svc.registerTab({
-          id: 'time-machine',
-          title: () => {
-            const a = ctx.locale && ctx.locale.getSnapshot && ctx.locale.getSnapshot().active || 'en';
-            return a.startsWith('ru') ? 'Машина времени' : 'Time Machine';
-          },
-          order: 30,
-          single: true,
-          icon: (size) => React.createElement('svg', { width: size||16, height: size||16, viewBox: '0 0 24 24', fill: 'none', stroke: 'currentColor', strokeWidth: '2', strokeLinecap: 'round', strokeLinejoin: 'round' },
-            React.createElement('circle', { cx:12, cy:12, r:10 }),
-            React.createElement('polyline', { points:'12 6 12 12 16 14' })
-          ),
-          component: (p) => React.createElement(TimeMachineTab, { ctx, ...p })
-        });
-      } catch (e) { console.warn('[dsh-time-machine] betterSidebar tab failed', e); }
-    }
-
     module.exports.inject = ['slots', 'locale'];
     module.exports.apply = function apply(ctx) {
       ensureStyles();

package/lib/index.js

@@ -12,6 +12,20 @@ export const Config = Schema.object({
 
 const NS = '@goodandready/dsh-time-machine';
 
+function sessionIdOf(execution, ctx) {
+  try {
+    if (execution && execution.sessionId) return String(execution.sessionId);
+    if (execution && execution.agent && execution.agent.session) {
+      return String(execution.agent.session.id || execution.agent.session.header?.id || '');
+    }
+    if (ctx && ctx.session) return String(ctx.session.id || ctx.session.header?.id || '');
+    if (ctx && ctx.get && typeof ctx.get === 'function') {
+      try { const s = ctx.get('session'); if (s) return String(s.id || s.header?.id || ''); } catch {}
+    }
+  } catch {}
+  return '';
+}
+
 export function apply(ctx, config) {
   let getConfig = () => config;
   let engine = new ShadowSnapshotEngine({ maxSnapshots: config?.maxSnapshots ?? 20 });
@@ -25,30 +39,74 @@ export function apply(ctx, config) {
     sctx.effect(() => () => { try { stop(); } catch {} }, 'dsh-time-machine: settings watch');
   });
 
-  // tools
+  // auto-snapshot on turn/start and approval/asked (session-scoped)
+  const autoSnap = async (label, sessId) => {
+    if (!getConfig().autoSnapshotEnabled) return;
+    try {
+      const sid = String(sessId || '').trim();
+      await engine.createSnapshot(label, { sessionId: sid });
+    } catch {}
+  };
+
+  // listen to DSH events if available
+  try {
+    if (ctx.events && typeof ctx.events.on === 'function') {
+      ctx.effect(() => {
+        const offs = [];
+        try {
+          offs.push(ctx.events.on('turn/start', (ev) => {
+            const sid = sessionIdOf(ev, ctx);
+            autoSnap(`auto:turn:${ev?.turnId || Date.now()}`, sid);
+          }));
+        } catch {}
+        try {
+          offs.push(ctx.events.on('approval/asked', (ev) => {
+            const sid = sessionIdOf(ev, ctx);
+            const tool = ev?.tool || ev?.name || 'approval';
+            autoSnap(`auto:approval:${tool}`, sid);
+          }));
+        } catch {}
+        return () => { for (const off of offs) try { typeof off === 'function' && off(); } catch {} };
+      }, 'dsh-time-machine: auto snapshot events');
+    }
+  } catch {}
+
+  // tools (session-aware)
   const registerTools = (tctx) => {
     tctx.tools.register({
       name: 'time_machine_checkpoint_create',
-      description: 'Create a workspace checkpoint (shadow git snapshot) before risky changes. Returns id and label.',
+      description: 'Create a workspace checkpoint (shadow git snapshot) before risky changes. Returns id and label. Auto-creates per session if autoSnapshotEnabled.',
       parameters: {
         type: 'object',
         properties: {
           label: { type: 'string', description: 'Human label for checkpoint' },
+          sessionId: { type: 'string', description: 'Session id to scope checkpoint (auto-detected if omitted)' },
         },
       },
-      execute: async ({ label } = {}) => {
-        const snap = await engine.createSnapshot(label);
+      execute: async (args = {}, execution) => {
+        const sid = String(args.sessionId || sessionIdOf(execution, tctx) || sessionIdOf(args, tctx) || '').trim();
+        const snap = await engine.createSnapshot(args.label, { sessionId: sid });
         return { success: true, snapshot: snap };
       },
     });
 
     tctx.tools.register({
       name: 'time_machine_checkpoint_list',
-      description: 'List recent workspace checkpoints newest first.',
-      parameters: { type: 'object', properties: {} },
-      execute: async () => {
-        const list = engine.listSnapshots();
-        return { success: true, snapshots: list };
+      description: 'List recent workspace checkpoints newest first. Filter by sessionId if given.',
+      parameters: {
+        type: 'object',
+        properties: {
+          sessionId: { type: 'string', description: 'Filter by session id' },
+        },
+      },
+      execute: async (args = {}, execution) => {
+        const sid = args.sessionId != null ? String(args.sessionId).trim() : (sessionIdOf(execution, tctx) ? String(sessionIdOf(execution, tctx)).trim() : undefined);
+        const list = sid !== undefined ? engine.listSnapshots(sid) : engine.listSnapshots();
+        // if sid undefined and we want all, return all; but if sessionId was auto-detected, filter
+        // For backward compat, if no sid provided and engine has sessionIds, return all
+        // If sid was auto-detected (execution has session), use it
+        const finalList = (args.sessionId == null && sid !== undefined && sid !== '') ? engine.listSnapshots(sid) : (args.sessionId != null ? engine.listSnapshots(String(args.sessionId)) : engine.listSnapshots());
+        return { success: true, snapshots: finalList, sessionId: sid || '' };
       },
     });
 
@@ -92,7 +150,7 @@ export function apply(ctx, config) {
     else ctx.inject(['tools'], (tctx) => registerTools(tctx));
   } catch {}
 
-  // web routes for UI
+  // web routes for UI (session-aware via ?sessionId=)
   ctx.effect(() => {
     const disposals = [];
     try {
@@ -100,8 +158,11 @@ export function apply(ctx, config) {
         kind: 'exact',
         path: '/dsh-time-machine/snapshots',
         handler: (req, res) => {
+          const url = new URL(req.url, 'http://localhost');
+          const sid = url.searchParams.get('sessionId');
+          const list = sid != null ? engine.listSnapshots(String(sid)) : engine.listSnapshots();
           res.setHeader('content-type', 'application/json');
-          res.end(JSON.stringify({ success: true, snapshots: engine.listSnapshots() }));
+          res.end(JSON.stringify({ success: true, snapshots: list }));
         },
       }));
       disposals.push(ctx.webServer.register({
@@ -131,7 +192,8 @@ export function apply(ctx, config) {
           req.on('end', async () => {
             try {
               const parsed = body ? JSON.parse(body) : {};
-              const snap = await engine.createSnapshot(parsed.label);
+              const sid = String(parsed.sessionId || new URL(req.url, 'http://localhost').searchParams.get('sessionId') || '').trim();
+              const snap = await engine.createSnapshot(parsed.label, { sessionId: sid });
               res.setHeader('content-type', 'application/json');
               res.end(JSON.stringify({ success: true, snapshot: snap }));
             } catch (e) {
@@ -166,6 +228,5 @@ export function apply(ctx, config) {
     return () => { for (const d of disposals) try { typeof d === 'function' && d(); } catch {} };
   }, 'dsh-time-machine: web routes');
 
-  // expose engine for tests
   ctx.provide?.('timeMachineEngine', engine);
 }

package/lib/snapshot.js

@@ -16,19 +16,28 @@ async function defaultExec(cmd, args, opts = {}) {
   }
 }
 
-// ponytail: in-memory engine, git shadow refs if repo present; O(n) scan, global lock
+// ponytail: in-memory engine, git shadow refs if repo present; O(n) scan, per-session trim
 export class ShadowSnapshotEngine {
   constructor({ exec = defaultExec, maxSnapshots = 20, cwd } = {}) {
     this.exec = exec;
     this.maxSnapshots = maxSnapshots;
     this.cwd = cwd;
-    this.snapshots = []; // newest last, list returns newest first
+    this.snapshots = []; // {id, label, sessionId, createdAt, commit, ref}
   }
 
   _now() { return Date.now(); }
 
-  _trim() {
-    while (this.snapshots.length > this.maxSnapshots) this.snapshots.shift();
+  _trimFor(sessionId) {
+    if (!sessionId) {
+      while (this.snapshots.length > this.maxSnapshots) this.snapshots.shift();
+      return;
+    }
+    const perSession = this.snapshots.filter(s => s.sessionId === sessionId);
+    while (perSession.length > this.maxSnapshots) {
+      const oldest = perSession.shift();
+      const idx = this.snapshots.indexOf(oldest);
+      if (idx !== -1) this.snapshots.splice(idx, 1);
+    }
   }
 
   async _isGitRepo() {
@@ -38,36 +47,38 @@ export class ShadowSnapshotEngine {
     } catch { return false; }
   }
 
-  async createSnapshot(label = '') {
+  async createSnapshot(label = '', { sessionId = '' } = {}) {
     const id = crypto.randomUUID().slice(0, 8);
     const createdAt = this._now();
     const safeLabel = String(label ?? '').trim() || `checkpoint-${id}`;
+    const sid = String(sessionId || '').trim();
     let commit = null;
     let ref = null;
     const inGit = await this._isGitRepo();
     if (inGit) {
       try {
-        // stage working tree without committing to main branch
         await this.exec('git', ['add', '-A'], this.cwd ? { cwd: this.cwd } : {});
         const { stdout: tree } = await this.exec('git', ['write-tree'], this.cwd ? { cwd: this.cwd } : {});
         const treeHash = String(tree).trim();
         const { stdout: commitHash } = await this.exec('git', ['commit-tree', treeHash, '-m', safeLabel], this.cwd ? { cwd: this.cwd } : {});
         commit = String(commitHash).trim();
-        ref = `refs/dsh-time-machine/${id}`;
+        ref = sid ? `refs/dsh-time-machine/${sid}/${id}` : `refs/dsh-time-machine/${id}`;
         await this.exec('git', ['update-ref', ref, commit], this.cwd ? { cwd: this.cwd } : {});
       } catch {
         commit = null;
         ref = null;
       }
     }
-    const snap = { id, label: safeLabel, createdAt, commit, ref };
+    const snap = { id, label: safeLabel, sessionId: sid, createdAt, commit, ref };
     this.snapshots.push(snap);
-    this._trim();
+    this._trimFor(sid);
     return snap;
   }
 
-  listSnapshots() {
-    return [...this.snapshots].sort((a, b) => b.createdAt - a.createdAt);
+  listSnapshots(sessionId) {
+    const sid = sessionId != null ? String(sessionId).trim() : undefined;
+    const list = sid !== undefined ? this.snapshots.filter(s => String(s.sessionId) === sid) : [...this.snapshots];
+    return [...list].sort((a, b) => b.createdAt - a.createdAt);
   }
 
   getSnapshot(id) {
@@ -91,7 +102,6 @@ export class ShadowSnapshotEngine {
       try {
         await this.exec('git', ['reset', '--hard', snap.commit], this.cwd ? { cwd: this.cwd } : {});
       } catch (e) {
-        // fallback to checkout of commit tree
         await this.exec('git', ['read-tree', snap.commit], this.cwd ? { cwd: this.cwd } : {}).catch(()=>{});
         await this.exec('git', ['checkout-index', '-a', '-f'], this.cwd ? { cwd: this.cwd } : {}).catch(()=>{});
       }
@@ -107,7 +117,6 @@ export class ShadowSnapshotEngine {
       throw err;
     }
     let to = toId ? this.getSnapshot(toId) : null;
-    // if to not given, diff against current HEAD/working tree
     const inGit = await this._isGitRepo();
     if (inGit && from.commit) {
       try {
@@ -116,7 +125,6 @@ export class ShadowSnapshotEngine {
         const diffStat = String(stdout ?? '').trim();
         if (diffStat) return { from: fromId, to: toId || 'HEAD', diff: diffStat };
       } catch {}
-      // fallback to name-only
       try {
         const range = to?.commit ? `${from.commit}..${to.commit}` : from.commit;
         const { stdout } = await this.exec('git', ['diff', '--name-only', range], this.cwd ? { cwd: this.cwd } : {});
@@ -129,6 +137,11 @@ export class ShadowSnapshotEngine {
 
   setMax(n) {
     this.maxSnapshots = Math.max(1, Number(n) || 20);
-    this._trim();
+    // trim all sessions
+    const sessions = [...new Set(this.snapshots.map(s => s.sessionId))];
+    for (const sid of sessions) this._trimFor(sid);
+    if (sessions.length === 0) {
+      while (this.snapshots.length > this.maxSnapshots) this.snapshots.shift();
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-time-machine",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "DSH plugin for smart checkpoints, workspace safety guards, and instant rollback",
   "type": "module",
   "main": "lib/index.js",