@logicseek/hello-cc 1.0.2 → 1.1.0-rc.1

package/lib/runtime/native/store.mjs

@@ -1,32 +1,70 @@
 import fs from 'node:fs';
 import path from 'node:path';
+import process from 'node:process';
 import { DatabaseSync } from 'node:sqlite';
 import { randomBytes } from 'node:crypto';
 import { CliError } from '../../shared/errors.mjs';
+import { resolveProjectDatabase, ensurePrivateProjectStateSubdirectory } from '../project-path.mjs';
+import { unsafeDirectoryAcl } from '../project-trust.mjs';
+import { readPrivateTextFile } from '../private-file.mjs';
 
 function statOrMissing(file) {
   try { return fs.lstatSync(file); }
   catch (error) { if (error.code === 'ENOENT') return null; throw error; }
 }
 
-function directory(file, create) {
+function privateDatabase(file) {
   let stat = statOrMissing(file);
-  if (!stat && create) { fs.mkdirSync(file, { mode: 0o700 }); stat = fs.lstatSync(file); }
-  if (!stat) return false;
-  if (!stat.isDirectory() || stat.isSymbolicLink()) throw new CliError('NATIVE_STATE_UNSAFE', `Native state must be a real directory: ${file}`);
-  return true;
+  if (!stat) {
+    try {
+      const fd = fs.openSync(file, fs.constants.O_RDWR | fs.constants.O_CREAT |
+        fs.constants.O_EXCL | (fs.constants.O_NOFOLLOW || 0), 0o600);
+      fs.closeSync(fd);
+    } catch (error) { if (error?.code !== 'EEXIST') throw error; }
+    stat = fs.lstatSync(file);
+  }
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 ||
+      (typeof process.getuid === 'function' && stat.uid !== process.getuid()) ||
+      (process.platform !== 'win32' && (stat.mode & 0o022) !== 0) ||
+      unsafeDirectoryAcl(file, stat)) {
+    throw new CliError('NATIVE_STATE_UNSAFE', `Native database must be an owned regular file: ${file}`);
+  }
+  const fd = fs.openSync(file, fs.constants.O_RDWR | (fs.constants.O_NOFOLLOW || 0));
+  try {
+    const opened = fs.fstatSync(fd);
+    if (!opened.isFile() || opened.dev !== stat.dev || opened.ino !== stat.ino ||
+        (process.platform !== 'win32' && (opened.mode & 0o022) !== 0) ||
+        unsafeDirectoryAcl(file, opened)) {
+      throw new CliError('NATIVE_STATE_UNSAFE', `Native database changed during validation: ${file}`);
+    }
+    if (process.platform !== 'win32' && (opened.mode & 0o777) !== 0o600) fs.fchmodSync(fd, 0o600);
+    const current = fs.lstatSync(file);
+    if (current.isSymbolicLink() || current.dev !== stat.dev || current.ino !== stat.ino) {
+      throw new CliError('NATIVE_STATE_UNSAFE', `Native database changed during validation: ${file}`);
+    }
+  } finally { fs.closeSync(fd); }
 }
 
 export function nativePaths(ctx, { create = false } = {}) {
   const root = fs.realpathSync(ctx.root);
-  const parent = path.join(root, '.hello-cc');
-  if (!directory(parent, create)) return null;
-  const dir = path.join(parent, 'native');
-  if (!directory(dir, create)) return null;
+  let dir;
+  try {
+    resolveProjectDatabase({ root, createStateDir: create });
+    dir = ensurePrivateProjectStateSubdirectory(root, 'native', { create });
+  } catch (error) {
+    if (error?.code === 'PROJECT_PATH_FORBIDDEN') {
+      throw new CliError('NATIVE_STATE_UNSAFE', error.message);
+    }
+    throw error;
+  }
+  if (!dir) return null;
   for (const name of ['runtime.json', 'state.db', 'state.db-wal', 'state.db-shm', 'runtime.log']) {
     const file = path.join(dir, name);
     const stat = statOrMissing(file);
-    if (stat && (stat.isSymbolicLink() || !stat.isFile() || stat.nlink !== 1)) {
+    if (stat && (stat.isSymbolicLink() || !stat.isFile() || stat.nlink !== 1 ||
+        (typeof process.getuid === 'function' && stat.uid !== process.getuid()) ||
+        (process.platform !== 'win32' && (stat.mode & 0o022) !== 0) ||
+        unsafeDirectoryAcl(file, stat))) {
       throw new CliError('NATIVE_STATE_UNSAFE', `Native state file is not a regular file: ${file}`);
     }
   }
@@ -43,10 +81,18 @@ export function writeNativePointer(ctx, value) {
 
 export function readNativePointer(ctx) {
   const paths = nativePaths(ctx);
-  if (!paths || !fs.existsSync(paths.pointer)) return null;
-  if (fs.statSync(paths.pointer).size > 16384) throw new CliError('NATIVE_STATE_UNSAFE', 'Native runtime pointer is too large');
+  if (!paths) return null;
+  let raw;
+  try { raw = readPrivateTextFile(paths.pointer, { maxBytes: 16384 }); }
+  catch (error) {
+    if (error?.code === 'PROJECT_PATH_FORBIDDEN') {
+      throw new CliError('NATIVE_STATE_UNSAFE', error.message);
+    }
+    throw error;
+  }
+  if (raw === null) return null;
   let value;
-  try { value = JSON.parse(fs.readFileSync(paths.pointer, 'utf8')); }
+  try { value = JSON.parse(raw); }
   catch { throw new CliError('NATIVE_STATE_INVALID', 'Native runtime pointer is invalid'); }
   if (!value || typeof value !== 'object' || Array.isArray(value) ||
       value.root !== fs.realpathSync(ctx.root) || value.meshDb !== path.resolve(ctx.dbPath) ||
@@ -60,8 +106,8 @@ export function readNativePointer(ctx) {
 
 export function createNativeStore(ctx) {
   const paths = nativePaths(ctx, { create: true });
+  privateDatabase(paths.db);
   const db = new DatabaseSync(paths.db, { timeout: 5000 });
-  fs.chmodSync(paths.db, 0o600);
   db.exec(`PRAGMA journal_mode = WAL;
     PRAGMA busy_timeout = 5000;
     PRAGMA foreign_keys = ON;
@@ -72,11 +118,16 @@ export function createNativeStore(ctx) {
     CREATE TABLE IF NOT EXISTS deliveries (
       id INTEGER PRIMARY KEY, peer TEXT NOT NULL, message_id INTEGER NOT NULL,
       submission_id TEXT NOT NULL UNIQUE, state TEXT NOT NULL, turn_id TEXT,
-      detail TEXT, updated_at INTEGER NOT NULL, UNIQUE(peer, message_id)
+      detail TEXT, origin TEXT NOT NULL DEFAULT 'peer', updated_at INTEGER NOT NULL, UNIQUE(peer, message_id)
     );
     CREATE TABLE IF NOT EXISTS provider_events (
       id INTEGER PRIMARY KEY, peer TEXT NOT NULL, payload TEXT NOT NULL, created_at INTEGER NOT NULL
     );`);
+  // Existing deliveries came from the shared message bus. Migration must not
+  // promote a stored sender name into user authority.
+  if (!db.prepare('PRAGMA table_info(deliveries)').all().some(column => column.name === 'origin')) {
+    db.exec("ALTER TABLE deliveries ADD COLUMN origin TEXT NOT NULL DEFAULT 'peer'");
+  }
   const now = () => Date.now();
   return {
     db,
@@ -88,9 +139,10 @@ export function createNativeStore(ctx) {
         cwd=excluded.cwd, status=excluded.status, updated_at=excluded.updated_at`)
         .run(worker.peer, worker.provider, worker.sessionId || null, worker.cwd, worker.status, now());
     },
-    queue(peer, messageId, submissionId) {
-      db.prepare(`INSERT OR IGNORE INTO deliveries(peer,message_id,submission_id,state,updated_at) VALUES (?,?,?,'queued',?)`)
-        .run(peer, messageId, submissionId, now());
+    queue(peer, messageId, submissionId, origin = 'peer') {
+      if (!['peer', 'user'].includes(origin)) throw new CliError('BAD_ARGS', 'Unknown native message origin');
+      db.prepare(`INSERT OR IGNORE INTO deliveries(peer,message_id,submission_id,state,origin,updated_at) VALUES (?,?,?,'queued',?,?)`)
+        .run(peer, messageId, submissionId, origin, now());
       return this.delivery(peer, messageId);
     },
     delivery(peer, messageId) { return db.prepare('SELECT * FROM deliveries WHERE peer=? AND message_id=?').get(peer, messageId) || null; },

package/lib/runtime/paths.mjs

@@ -1,7 +1,22 @@
-import os from 'node:os';
+import fs from 'node:fs';
 import path from 'node:path';
+import { privateProjectStateDir, privateProjectAuthorityPath, validatedGlobalStateDir } from './private-state.mjs';
+import { stableProjectStateRoot } from './project-trust.mjs';
 
 export function projectStateDir(root) {
+  const privateDir = privateProjectStateDir(root);
+  // An established private binding is authoritative even if permissions on
+  // the project path later change. A damaged or unreadable private store must
+  // fail validation, never silently reactivate an old project-local database.
+  try { fs.lstatSync(privateDir); return privateDir; }
+  catch (error) { if (error?.code !== 'ENOENT') return privateDir; }
+  try { fs.lstatSync(privateProjectAuthorityPath(root)); return privateDir; }
+  catch (error) { if (error?.code !== 'ENOENT') return privateDir; }
+  const stableRoot = stableProjectStateRoot(root);
+  return stableRoot ? path.join(stableRoot, '.hello-cc') : privateDir;
+}
+
+export function legacyProjectStateDir(root) {
   return path.join(root, '.hello-cc');
 }
 
@@ -18,7 +33,7 @@ export function webLogPath(ctx) {
 }
 
 export function globalStateDir() {
-  return path.join(os.homedir(), '.hello-cc');
+  return validatedGlobalStateDir();
 }
 
 export function globalRuntimePath() {

package/lib/runtime/private-file.mjs

@@ -0,0 +1,76 @@
+import fs from 'node:fs';
+import process from 'node:process';
+import { CliError } from '../shared/errors.mjs';
+import { unsafeDirectoryAcl } from './project-trust.mjs';
+
+function forbidden(file) {
+  return new CliError('PROJECT_PATH_FORBIDDEN', `Managed file must be an owned private regular file: ${file}`);
+}
+
+export function openPrivateAppendFile(file) {
+  const flags = fs.constants.O_WRONLY | fs.constants.O_APPEND | fs.constants.O_CREAT |
+    (fs.constants.O_NOFOLLOW || 0);
+  let fd;
+  try {
+    fd = fs.openSync(file, flags, 0o600);
+    const opened = fs.fstatSync(fd);
+    if (!opened.isFile() || opened.nlink !== 1 ||
+        (typeof process.getuid === 'function' && opened.uid !== process.getuid()) ||
+        (process.platform !== 'win32' && (opened.mode & 0o777) !== 0o600) ||
+        unsafeDirectoryAcl(file, opened)) {
+      throw forbidden(file);
+    }
+    const current = fs.lstatSync(file);
+    const secured = fs.fstatSync(fd);
+    if (current.isSymbolicLink() || !current.isFile() || current.nlink !== 1 ||
+        current.dev !== secured.dev || current.ino !== secured.ino ||
+        (typeof process.getuid === 'function' && current.uid !== process.getuid()) ||
+        (process.platform !== 'win32' && (secured.mode & 0o777) !== 0o600)) {
+      throw forbidden(file);
+    }
+    return fd;
+  } catch (error) {
+    if (fd !== undefined) fs.closeSync(fd);
+    if (error instanceof CliError) throw error;
+    throw forbidden(file);
+  }
+}
+
+export function readPrivateTextFile(file, { maxBytes = 65536 } = {}) {
+  let before;
+  try { before = fs.lstatSync(file); }
+  catch (error) {
+    if (error?.code === 'ENOENT') return null;
+    throw forbidden(file);
+  }
+  if (before.isSymbolicLink() || !before.isFile() || before.nlink !== 1 ||
+      (typeof process.getuid === 'function' && before.uid !== process.getuid()) ||
+      (process.platform !== 'win32' && (before.mode & 0o777) !== 0o600) ||
+      before.size > maxBytes || unsafeDirectoryAcl(file, before)) {
+    throw forbidden(file);
+  }
+  let fd;
+  try {
+    fd = fs.openSync(file, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+    const opened = fs.fstatSync(fd);
+    if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== before.dev ||
+        opened.ino !== before.ino || opened.size > maxBytes ||
+        (typeof process.getuid === 'function' && opened.uid !== process.getuid()) ||
+        (process.platform !== 'win32' && (opened.mode & 0o777) !== 0o600)) {
+      throw forbidden(file);
+    }
+    const content = fs.readFileSync(fd, 'utf8');
+    const after = fs.lstatSync(file);
+    const current = fs.fstatSync(fd);
+    if (after.isSymbolicLink() || after.dev !== opened.dev || after.ino !== opened.ino ||
+        current.size !== opened.size || current.mtimeMs !== opened.mtimeMs) {
+      throw forbidden(file);
+    }
+    return content;
+  } catch (error) {
+    if (error instanceof CliError) throw error;
+    throw forbidden(file);
+  } finally {
+    if (fd !== undefined) fs.closeSync(fd);
+  }
+}