@ductape/cli 0.3.36 → 0.4.0

package/dist/commands/sessions-validate.d.ts

@@ -0,0 +1,3 @@
+export declare function runSessionsValidate(opts?: {
+    json?: boolean;
+}): Promise<void>;

package/dist/commands/sessions-validate.js

@@ -0,0 +1,12 @@
+import { findProjectConfig } from '../lib/config.js';
+import { fail } from '../lib/output.js';
+import { formatSessionConformance, validateSessionConformance } from '../lib/session-conformance.js';
+export async function runSessionsValidate(opts = {}) {
+    const found = findProjectConfig();
+    if (!found)
+        fail('No linked project. Run `ductape link` from your project directory (or `ductape init`).');
+    const result = validateSessionConformance(found.dir);
+    console.log(opts.json ? JSON.stringify(result, null, 2) : formatSessionConformance(result));
+    if (!result.ok)
+        process.exitCode = 1;
+}

package/dist/index.js

@@ -19,6 +19,7 @@ import { runDb, runDbActions, runDbContext } from './commands/db.js';
 import { runComponentActions } from './commands/component-actions.js';
 import { runDbMigrate, runDbMigrateStatus, runDbMigrateRollback } from './commands/db-migrate.js';
 import { runFeaturesSync, runFeaturesValidate } from './commands/features-sync.js';
+import { runSessionsValidate } from './commands/sessions-validate.js';
 import { runDbSchemaGenerate, runDbSchemaPush } from './commands/db-schema.js';
 import { runGraph } from './commands/graph.js';
 import { runSecretImportEnv, runSecrets } from './commands/secrets.js';
@@ -895,6 +896,12 @@ db
     return runDb(verb, { file: opts.file, json: opts.json });
 }));
 const features = program.command('features').description('Code-first Ductape Features (ductape/features/)');
+const sessions = program.command('sessions').description('Session lifecycle and propagation checks');
+sessions
+    .command('validate')
+    .description('Read-only project-wide audit of Ductape SDK session propagation')
+    .option('--json', 'JSON output')
+    .action(wrap((opts) => runSessionsValidate({ json: Boolean(opts.json) })));
 features
     .command('validate')
     .description('Read-only AST validation of code-first Feature control flow; performs no remote mutation')

package/dist/lib/session-conformance.d.ts

@@ -0,0 +1,16 @@
+export type SessionClassification = 'explicit' | 'inherited' | 'delegated' | 'system' | 'missing';
+export interface SessionFinding {
+    file: string;
+    line: number;
+    call: string;
+    classification: SessionClassification;
+    reason?: string;
+}
+export interface SessionValidationResult {
+    ok: boolean;
+    root: string;
+    summary: Record<SessionClassification | 'calls', number>;
+    findings: SessionFinding[];
+}
+export declare function validateSessionConformance(rootDir: string): SessionValidationResult;
+export declare function formatSessionConformance(result: SessionValidationResult): string;

package/dist/lib/session-conformance.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const EXTENSIONS = new Set(['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs']);
+const IGNORED = new Set(['.git', 'dist', 'build', 'coverage', 'node_modules']);
+const CALL = /\b(?:ductape\.)?(api|feature|database|databases|graph|vector|storage|events|notifications|quota|fallback)\.([A-Za-z_$][\w$]*)\s*\(/g;
+function walk(root, files) {
+    for (const entry of fs.readdirSync(root, { withFileTypes: true })) {
+        if (entry.isSymbolicLink() || IGNORED.has(entry.name))
+            continue;
+        const target = path.join(root, entry.name);
+        if (entry.isDirectory())
+            walk(target, files);
+        else if (EXTENSIONS.has(path.extname(entry.name)))
+            files.push(target);
+    }
+}
+function invocation(source, open) {
+    let depth = 0;
+    let quote = '';
+    let escaped = false;
+    for (let i = open; i < source.length; i += 1) {
+        const char = source[i];
+        if (quote) {
+            if (escaped)
+                escaped = false;
+            else if (char === '\\')
+                escaped = true;
+            else if (char === quote)
+                quote = '';
+            continue;
+        }
+        if (char === '"' || char === "'" || char === '`') {
+            quote = char;
+            continue;
+        }
+        if (char === '(')
+            depth += 1;
+        if (char === ')' && --depth === 0)
+            return source.slice(open + 1, i);
+    }
+    return source.slice(open + 1);
+}
+export function validateSessionConformance(rootDir) {
+    const root = path.resolve(rootDir);
+    const files = [];
+    walk(root, files);
+    const findings = [];
+    for (const file of files) {
+        const source = fs.readFileSync(file, 'utf8');
+        let match;
+        while ((match = CALL.exec(source))) {
+            const call = `${match[1]}.${match[2]}`;
+            const line = source.slice(0, match.index).split('\n').length;
+            const args = invocation(source, source.indexOf('(', match.index));
+            const nearby = source.slice(Math.max(0, match.index - 300), match.index);
+            let classification = 'missing';
+            let reason;
+            if (/\bsession\s*:/.test(args))
+                classification = 'explicit';
+            else if (/\bctx\.$/.test(nearby))
+                classification = 'inherited';
+            else {
+                const marker = nearby.match(/ductape-session:\s*(delegated|system)\s+([^\n]+)/i);
+                if (marker) {
+                    classification = marker[1].toLowerCase();
+                    reason = marker[2].trim();
+                }
+            }
+            findings.push({ file: path.relative(root, file).split(path.sep).join('/'), line, call, classification, reason });
+        }
+    }
+    const summary = { calls: findings.length, explicit: 0, inherited: 0, delegated: 0, system: 0, missing: 0 };
+    for (const finding of findings)
+        summary[finding.classification] += 1;
+    return { ok: summary.missing === 0, root, summary, findings };
+}
+export function formatSessionConformance(result) {
+    const lines = [`Session propagation: ${result.ok ? 'PASS' : 'FAIL'} (${result.summary.calls} calls)`];
+    for (const finding of result.findings.filter((item) => item.classification === 'missing'))
+        lines.push(`  ${finding.file}:${finding.line} ${finding.call} has no explicit, inherited, delegated, or system session classification`);
+    return lines.join('\n');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ductape/cli",
-  "version": "0.3.36",
+  "version": "0.4.0",
   "description": "Ductape CLI — local platform, login, link projects, and manage resources via the proxy (Workbench-compatible)",
   "type": "module",
   "main": "dist/index.js",