zcode-pro 0.16.0__py3-none-any.whl

zcode_pro/app/src/host/taskIndex.mjs

@@ -0,0 +1,255 @@
+// 任务索引（~/.zcode/v2/tasks-index.sqlite）的路径重映射。
+// 项目切换文件夹后，侧边栏项目列表与任务历史由该库派生，需同步更新其中的路径引用。
+//
+// workspace 列分布（逆向自真实库 schema）：
+// - 仅 workspace_key：task_group_workspace_bootstraps（主键）、automation_runs；
+// - workspace_key + workspace_path + workspace_identity：
+//   tasks（key 为联合主键）、automations、off_peak_tasks、task_group_members（key 为联合主键）；
+// - 另有 tasks.meta_json 内嵌 "workspacePath":"<路径>"；
+//   task_group_view_node_orders.node_key（node_type='task'）内嵌 JSON 数组 ["<workspace_key>","<task_id>"]；
+// - workspace_identity 格式未详，按“引号界定的精确串”替换（哈希值不会含路径，LIKE 只做免更新过滤）；
+// - tasks.searchable_text 是会话内容文本（可能提及任何路径），不属于路径引用，不动。
+//
+// 驱动：优先 node:sqlite（Node ≥23.4 内置），退回 sqlite3 CLI；两者都没有则返回 null，
+// 调用方自行降级（只移动目录与更新 setting.json）。
+// 并发：ZCode 宿主进程持有该库（WAL 模式），所有写入走 BEGIN IMMEDIATE + busy_timeout。
+
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+
+const BUSY_TIMEOUT_MS = 5000;
+
+export function taskIndexPath(dataRoot) {
+  return join(dataRoot, 'v2', 'tasks-index.sqlite');
+}
+
+export async function taskIndexDriverAvailable() {
+  return (await loadDriver()) !== null;
+}
+
+async function loadDriver() {
+  // ZCODEPRO_SQLITE_DRIVER=cli：调试/测试用，强制走 sqlite3 CLI 驱动
+  if (String(process.env.ZCODEPRO_SQLITE_DRIVER || '').toLowerCase() !== 'cli') {
+    try {
+      const { DatabaseSync } = await import('node:sqlite');
+      return { kind: 'node', DatabaseSync };
+    } catch { /* Node <23.4：退回 CLI */ }
+  }
+  try {
+    const r = spawnSync('sqlite3', ['--version'], { encoding: 'utf8' });
+    if (r.status === 0) return { kind: 'cli' };
+  } catch { /* 没有 sqlite3 可执行文件 */ }
+  return null;
+}
+
+// 探测：能在 BUSY_TIMEOUT 内拿到写锁。失败抛 { code: 'index-busy' | 'index-error' }。
+export async function probeTaskIndexWritable(dataRoot) {
+  const dbFile = taskIndexPath(dataRoot);
+  const driver = await loadDriver();
+  if (!driver) {
+    const err = new Error('缺少 SQLite 支持（需要 Node ≥23.4 或 sqlite3 命令）');
+    err.code = 'index-error';
+    throw err;
+  }
+  try {
+    if (driver.kind === 'node') {
+      const db = new driver.DatabaseSync(dbFile);
+      try {
+        db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+        db.exec('BEGIN IMMEDIATE');
+        db.exec('ROLLBACK');
+      } finally { db.close(); }
+    } else {
+      runCli(dbFile, 'BEGIN IMMEDIATE;\nROLLBACK;');
+    }
+  } catch (err) {
+    if (!isBusyError(err)) {
+      const e = new Error('任务索引不可写: ' + (err?.message || err));
+      e.code = 'index-error';
+      throw e;
+    }
+    const e = new Error('任务索引正被占用（ZCode 可能正在写入），请稍后重试');
+    e.code = 'index-busy';
+    throw e;
+  }
+}
+
+// 把索引中所有引用 oldPath 的 workspace 键/字段重映射为 newPath，单事务。
+// 返回 { changed }（SQLite changes() 计数之和，CLI 驱动返回 null）。
+export async function remapTaskIndexPaths(dataRoot, oldPath, newPath) {
+  const dbFile = taskIndexPath(dataRoot);
+  const driver = await loadDriver();
+  if (!driver) {
+    const err = new Error('缺少 SQLite 支持（需要 Node ≥23.4 或 sqlite3 命令）');
+    err.code = 'index-error';
+    throw err;
+  }
+  const sep = process.platform === 'win32' ? '\\' : '/';
+  // workspace_key 的两种拼写（正常化尾分隔符差异）
+  const variants = [
+    [oldPath, newPath],
+    [oldPath + sep, newPath + sep],
+  ];
+  // workspace_key 所在的表（精确等值替换，无前缀误伤风险）
+  const KEY_TABLES = ['tasks', 'task_group_members', 'task_group_workspace_bootstraps', 'automations', 'automation_runs', 'off_peak_tasks'];
+  // 带 workspace_path / workspace_identity 的表
+  const PATH_TABLES = ['tasks', 'automations', 'off_peak_tasks', 'task_group_members'];
+  // 引号界定的 JSON 字符串替换："/a/b/old" 不会命中 "/a/b/old2"
+  const quoted = (p) => JSON.stringify(p);
+  const metaToken = (p) => '"workspacePath":' + JSON.stringify(p);
+
+  if (driver.kind === 'node') return remapWithNode(driver.DatabaseSync, dbFile);
+  return remapWithCli(dbFile);
+
+  function remapWithNode(DatabaseSync, file) {
+    const db = new DatabaseSync(file);
+    let changed = 0;
+    try {
+      db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+      db.exec('BEGIN IMMEDIATE');
+      try {
+        const run = (sql, params) => {
+          changed += db.prepare(sql).run(...params).changes;
+        };
+        for (const [oldKey, newKey] of variants) {
+          for (const table of KEY_TABLES) {
+            run(`UPDATE ${table} SET workspace_key = ? WHERE workspace_key = ?`, [newKey, oldKey]);
+          }
+          for (const table of PATH_TABLES) {
+            run(`UPDATE ${table} SET workspace_path = ? WHERE workspace_path = ?`, [newKey, oldKey]);
+            run(`UPDATE ${table} SET workspace_identity = replace(workspace_identity, ?, ?)
+                 WHERE instr(workspace_identity, ?) > 0`, [quoted(oldKey), quoted(newKey), oldKey]);
+          }
+          run(`UPDATE tasks SET meta_json = replace(meta_json, ?, ?)
+               WHERE instr(meta_json, ?) > 0`, [metaToken(oldKey), metaToken(newKey), oldKey]);
+          run(`UPDATE task_group_view_node_orders SET node_key = replace(node_key, ?, ?)
+               WHERE instr(node_key, ?) > 0`, [quoted(oldKey), quoted(newKey), oldKey]);
+        }
+        db.exec('COMMIT');
+      } catch (err) {
+        try { db.exec('ROLLBACK'); } catch { /* 已回滚/连接失效 */ }
+        throw asRemapError(err);
+      }
+    } finally { db.close(); }
+    return { changed };
+  }
+
+  function remapWithCli(file) {
+    const esc = (v) => "'" + String(v).replace(/'/g, "''") + "'";
+    const stmts = [];
+    for (const [oldKey, newKey] of variants) {
+      for (const table of KEY_TABLES) {
+        stmts.push(`UPDATE ${table} SET workspace_key = ${esc(newKey)} WHERE workspace_key = ${esc(oldKey)};`);
+      }
+      for (const table of PATH_TABLES) {
+        stmts.push(`UPDATE ${table} SET workspace_path = ${esc(newKey)} WHERE workspace_path = ${esc(oldKey)};`);
+        stmts.push(`UPDATE ${table} SET workspace_identity = replace(workspace_identity, ${esc(quoted(oldKey))}, ${esc(quoted(newKey))})
+                    WHERE instr(workspace_identity, ${esc(oldKey)}) > 0;`);
+      }
+      stmts.push(`UPDATE tasks SET meta_json = replace(meta_json, ${esc(metaToken(oldKey))}, ${esc(metaToken(newKey))})
+                  WHERE instr(meta_json, ${esc(oldKey)}) > 0;`);
+      stmts.push(`UPDATE task_group_view_node_orders SET node_key = replace(node_key, ${esc(quoted(oldKey))}, ${esc(quoted(newKey))})
+                  WHERE instr(node_key, ${esc(oldKey)}) > 0;`);
+    }
+    try {
+      runCli(file, 'BEGIN IMMEDIATE;\n' + stmts.join('\n') + '\nCOMMIT;');
+    } catch (err) {
+      throw asRemapError(err);
+    }
+    return { changed: null };
+  }
+
+  function asRemapError(err) {
+    if (isBusyError(err)) {
+      const e = new Error('任务索引正被占用（ZCode 可能正在写入），请稍后重试');
+      e.code = 'index-busy';
+      return e;
+    }
+    const e = new Error(String(err?.message || err));
+    e.code = 'index-remap-failed';
+    return e;
+  }
+}
+
+// 已重命名会话的标题表：task_id → title（title_overridden = 1 且未删除）。
+// 只读单条 SELECT，不开事务；库不存在或没有 SQLite 支持时返回空表，
+// 调用方（会话名锁定）自然降级为不干预。
+export async function listOverriddenTitles(dataRoot) {
+  const dbFile = taskIndexPath(dataRoot);
+  if (!existsSync(dbFile)) return { titles: {} };
+  const driver = await loadDriver();
+  if (!driver) return { titles: {} };
+  const titles = {};
+  try {
+    if (driver.kind === 'node') {
+      const db = new driver.DatabaseSync(dbFile);
+      try {
+        db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+        for (const row of db.prepare(
+          'SELECT task_id, title FROM tasks WHERE title_overridden = 1 AND deleted = 0'
+        ).all()) {
+          titles[row.task_id] = row.title;
+        }
+      } finally { db.close(); }
+    } else {
+      // json_group_object：标题里的任意字符（含引号竖线）都被正确转义，整行即一个 JSON
+      const r = runCli(dbFile,
+        'SELECT coalesce(json_group_object(task_id, title), \'{}\') FROM tasks WHERE title_overridden = 1 AND deleted = 0;');
+      Object.assign(titles, JSON.parse(r.stdout.trim() || '{}'));
+    }
+  } catch (err) {
+    const e = new Error('读取任务索引失败: ' + (err?.message || err));
+    e.code = 'index-error';
+    return { error: e.message, code: e.code };
+  }
+  return { titles };
+}
+
+function isBusyError(err) {
+  const s = String(err?.code || '') + String(err?.message || '');
+  return /SQLITE_BUSY|database is locked/i.test(s);
+}
+
+// 任务（会话）ID → 工作区路径（无尾分隔符）：空闲回收在 Windows 上的后台命令
+// 归属判定用（命令行里只带会话 ID，需经索引反查它属于哪个项目）。
+// 读取失败返回空表，调用方按“无法归属”保守处理
+export async function listTaskWorkspaceMap(dataRoot) {
+  const out = {};
+  const dbFile = taskIndexPath(dataRoot);
+  if (!existsSync(dbFile)) return out;
+  const driver = await loadDriver();
+  if (!driver) return out;
+  try {
+    let rows = [];
+    if (driver.kind === 'node') {
+      const db = new driver.DatabaseSync(dbFile);
+      try {
+        db.exec(`PRAGMA busy_timeout = ${BUSY_TIMEOUT_MS}`);
+        rows = db.prepare('SELECT task_id, workspace_path, workspace_key FROM tasks').all();
+      } finally { db.close(); }
+    } else {
+      const r = runCli(dbFile,
+        "SELECT coalesce(json_group_array(json_object('id', task_id, 'path', workspace_path, 'key', workspace_key)), '[]') FROM tasks;");
+      rows = JSON.parse(r.stdout.trim() || '[]');
+    }
+    for (const row of rows) {
+      const id = row.task_id ?? row.id;
+      const ws = String(row.workspace_path ?? row.path ?? row.workspace_key ?? row.key ?? '').replace(/[\\/]+$/, '');
+      if (id && ws) out[id] = ws;
+    }
+  } catch { /* 读取失败按空表处理 */ }
+  return out;
+}
+
+function runCli(dbFile, script) {
+  const r = spawnSync('sqlite3', ['-bail', '-batch', dbFile], {
+    windowsHide: true,
+    input: `.timeout ${BUSY_TIMEOUT_MS}\n` + script,
+    encoding: 'utf8',
+    maxBuffer: 1 << 20,
+  });
+  if (r.error) throw r.error;
+  if (r.status !== 0) throw new Error('sqlite3 CLI 执行失败: ' + (r.stderr || r.stdout || ('exit ' + r.status)));
+  return r;
+}

zcode_pro/app/src/host/taskOrder.mjs

@@ -0,0 +1,117 @@
+// 会话（任务）手动排序持久化。
+// 侧边栏两个列表来源（逆向自应用查询）：
+// - 置顶 / 项目中的会话：按 tasks.updated_at DESC 排序，
+//   重排 = 按新顺序重盖 updated_at（同步 meta_json.updatedAt，避免下次合并回跳）；
+// - 分组中的会话：按 task_group_members.sort_order 升序（compareGroupTasks），
+//   重排 = 重写该组成员的 sort_order。
+// 两种都采用“子序列拼接”策略：仅调整拖动子集的相对位置，
+// 未出现在拖动结果里的任务保持原有相对次序。
+// 会话键格式与页面 data-task-item-key 一致：`<workspace_path>:<task_id>`（按最后一个 ':' 分割）。
+
+import { DatabaseSync } from 'node:sqlite';
+import { join } from 'node:path';
+
+function splitKey(k) {
+  const sep = k.lastIndexOf(':');
+  if (sep <= 0) return null;
+  return [k.slice(0, sep), k.slice(sep + 1)];
+}
+
+function withDb(dataRoot, fn) {
+  const db = new DatabaseSync(join(dataRoot, 'v2', 'tasks-index.sqlite'));
+  try {
+    db.exec('PRAGMA busy_timeout = 5000');
+    return fn(db);
+  } finally {
+    db.close();
+  }
+}
+
+// 在 current 全序中剔除子集后，把子集按新顺序插回其原有最小位置
+function spliceSubset(current, orderedSubset) {
+  const subset = new Set(orderedSubset);
+  let anchor = Infinity;
+  current.forEach((k, i) => { if (subset.has(k)) anchor = Math.min(anchor, i); });
+  if (!isFinite(anchor)) anchor = current.length;
+  const head = current.filter((k, i) => !subset.has(k) && i < anchor);
+  const tail = current.filter((k, i) => !subset.has(k) && i >= anchor);
+  return [...head, ...orderedSubset.filter((k) => subset.has(k)), ...tail];
+}
+
+export async function reorderWorkspaceTasks(dataRoot, orderedKeys) {
+  const first = splitKey(orderedKeys[0] || '');
+  if (!first) return { code: 'invalid-request', error: '无效的会话标识' };
+  const workspace = first[0];
+
+  return withDb(dataRoot, (db) => {
+    const current = db.prepare(
+      `SELECT task_id FROM tasks
+       WHERE workspace_key = ? AND deleted = 0
+       ORDER BY updated_at DESC, created_at DESC, task_id DESC`
+    ).all(workspace).map((r) => r.task_id);
+    if (current.length === 0) return { code: 'workspace-empty', error: '工作区不存在或没有会话' };
+
+    const next = spliceSubset(current, orderedKeys.map((k) => splitKey(k)[1]));
+    const now = Date.now();
+    const upd = db.prepare(
+      `UPDATE tasks SET updated_at = ?, meta_json = json_set(meta_json, '$.updatedAt', ?)
+       WHERE workspace_key = ? AND task_id = ?`
+    );
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      next.forEach((taskId, idx) => upd.run(now - idx * 1000, now - idx * 1000, workspace, taskId));
+      db.exec('COMMIT');
+    } catch (err) {
+      try { db.exec('ROLLBACK'); } catch { /* ignore */ }
+      return { code: 'order-write', error: '写入排序失败: ' + (err?.message || err) };
+    }
+    return { reordered: Math.min(orderedKeys.length, current.length), workspace };
+  });
+}
+
+export async function reorderGroupMembers(dataRoot, orderedKeys) {
+  return withDb(dataRoot, (db) => {
+    // 定位同时包含全部所列会话的组（应当唯一）
+    const counts = new Map();
+    const stmt = db.prepare(`SELECT group_id FROM task_group_members WHERE workspace_key = ? AND task_id = ?`);
+    for (const k of orderedKeys) {
+      const pair = splitKey(k);
+      if (!pair) return { code: 'invalid-request', error: '无效的会话标识: ' + k };
+      for (const r of stmt.all(...pair)) {
+        counts.set(r.group_id, (counts.get(r.group_id) || 0) + 1);
+      }
+    }
+    const groupIds = [...counts.entries()].filter(([, c]) => c === orderedKeys.length).map(([g]) => g);
+    if (groupIds.length !== 1) {
+      return groupIds.length === 0
+        ? { code: 'group-not-found', error: '未找到包含这些会话的分组' }
+        : { code: 'group-ambiguous', error: '无法唯一确定分组' };
+    }
+    const groupId = groupIds[0];
+
+    const current = db.prepare(
+      `SELECT workspace_key || ':' || task_id AS k
+       FROM task_group_members WHERE group_id = ?
+       ORDER BY COALESCE(sort_order, 2147483647) ASC, added_at ASC`
+    ).all(groupId).map((r) => r.k);
+
+    const next = spliceSubset(current, orderedKeys);
+    const upd = db.prepare(
+      `UPDATE task_group_members SET sort_order = ?, updated_at = ?
+       WHERE group_id = ? AND workspace_key = ? AND task_id = ?`
+    );
+    const now = Date.now();
+    db.exec('BEGIN IMMEDIATE');
+    try {
+      next.forEach((k, idx) => {
+        const [w, t] = splitKey(k);
+        upd.run(idx, now, groupId, w, t);
+      });
+      db.exec('COMMIT');
+    } catch (err) {
+      try { db.exec('ROLLBACK'); } catch { /* ignore */ }
+      return { code: 'order-write', error: '写入分组排序失败: ' + (err?.message || err) };
+    }
+    return { reordered: Math.min(orderedKeys.length, current.length), groupId };
+  });
+}

zcode_pro/app/src/host/webdav.mjs

@@ -0,0 +1,105 @@
+// WebDAV 传输（设置同步用）：用 curl 子进程完成 GET / PUT / MKCOL。
+// Basic 凭据经 stdin 的 --config 文件传入，不进命令行参数；代理由调用方以
+// proxyUrl 注入（与 helper 其他网络访问一致，空 = 不用代理）。
+import { spawn } from 'node:child_process';
+import { mkdtemp } from 'node:fs/promises'; // fs 的 mkdtemp 是回调版，await 它会把 undefined 当回调
+import { readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+// curl 退出码 → 人话（err.message 是整条命令行，对用户没有信息量）
+const CURL_EXIT = {
+  3: 'URL 格式错误',
+  6: '无法解析服务器地址',
+  7: '无法连接服务器',
+  28: '超时',
+  35: 'SSL 握手失败',
+  47: '重定向过多',
+  60: 'SSL 证书无效',
+};
+
+// HTTP 状态 → 同步场景的人话（404 不算失败，由调用方按“云端没有数据”处理）
+export function webdavHttpText(code) {
+  if (code === 401 || code === 403) return `登录或密码被拒绝（HTTP ${code}；坚果云等网盘需使用应用密码，不是登录密码）`;
+  if (code === 405) return '服务器不允许该操作（HTTP 405）';
+  if (code === 409) return '目标目录不存在（HTTP 409）';
+  if (code === 507) return '网盘空间不足（HTTP 507）';
+  return `HTTP ${code}`;
+}
+
+// curl 配置文件语法：双引号包裹，\ 与 " 需转义；换行无法出现在单行值里，替换为空格
+function curlQuote(v) {
+  return '"' + String(v).replace(/([\\"])/g, '\\$1').replace(/[\r\n]+/g, ' ') + '"';
+}
+
+function proxyEnvVars(proxyUrl) {
+  if (!proxyUrl) return {};
+  return {
+    HTTP_PROXY: proxyUrl, HTTPS_PROXY: proxyUrl,
+    http_proxy: proxyUrl, https_proxy: proxyUrl,
+  };
+}
+
+// 执行一次 WebDAV 请求。method 为 GET / PUT / MKCOL；PUT 用 uploadFile 上传
+// （-T 隐含 PUT）。返回 { ok, httpCode, body, error }：ok 表示 curl 本身执行
+// 成功（HTTP 4xx/5xx 也算 ok，由调用方看 httpCode 分支）；error 为中文原因。
+export async function webdavRequest({ method, url, login = '', password = '', uploadFile = null, proxyUrl = '', timeoutMs = 45000 }) {
+  const dir = await mkdtemp(join(tmpdir(), 'zcodepro-webdav-'));
+  const bodyFile = join(dir, 'body');
+  try {
+    const args = ['-sS', '--connect-timeout', '10', '--max-time', String(Math.max(10, Math.ceil(timeoutMs / 1000))),
+      '-w', '%{http_code}', '-o', bodyFile, '--config', '-'];
+    if (method === 'PUT' && uploadFile) {
+      args.push('-H', 'Content-Type: application/json', '-T', uploadFile);
+    } else {
+      args.push('-X', method);
+    }
+    args.push(url);
+    const cfg = login || password ? `user = ${curlQuote(`${login}:${password}`)}\n` : '';
+    const r = await new Promise((resolveRun) => {
+      const child = spawn('curl', args, { env: { ...process.env, ...proxyEnvVars(proxyUrl) }, stdio: ['pipe', 'pipe', 'pipe'], windowsHide: true });
+      let stdout = '';
+      let stderr = '';
+      child.stdout.on('data', (d) => { stdout += d.toString(); });
+      child.stderr.on('data', (d) => { stderr += d.toString(); });
+      child.on('error', (err) => {
+        if (err.code === 'ENOENT') resolveRun({ code: -1, stdout: '', stderr: '' });
+        else resolveRun({ code: -2, stdout: '', stderr: String(err.message || err) });
+      });
+      child.on('close', (code) => resolveRun({ code: code == null ? -2 : code, stdout, stderr }));
+      child.stdin.write(cfg);
+      child.stdin.end();
+    });
+    if (r.code === -1) return { ok: false, httpCode: null, body: '', error: '未找到 curl 命令（WebDAV 同步依赖 curl）' };
+    if (r.code !== 0) {
+      const why = CURL_EXIT[r.code] || `curl 退出码 ${r.code}`;
+      const hint = (r.stderr.split('\n').find((l) => l.trim()) || '').trim();
+      return { ok: false, httpCode: null, body: '', error: hint ? `${why}（${hint}）` : why };
+    }
+    let body = '';
+    try { body = readFileSync(bodyFile, 'utf8'); } catch { /* 无响应体 */ }
+    const httpCode = Number(parseInt(r.stdout.trim(), 10)) || 0;
+    return { ok: true, httpCode, body, error: '' };
+  } finally {
+    try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+  }
+}
+
+// PUT 前确保云端目录存在：409（父目录缺失）时逐段 MKCOL 再重试一次。
+// 已存在的目录 MKCOL 多半回 405，忽略即可——这里是尽力而为，最终成败仍看 PUT。
+export async function webdavPutWithMkcol({ url, login, password, uploadFile, proxyUrl, timeoutMs }) {
+  const auth = { login, password, proxyUrl };
+  const first = await webdavRequest({ method: 'PUT', url, uploadFile, ...auth, timeoutMs });
+  if (!first.ok || (first.httpCode >= 200 && first.httpCode < 300) || first.httpCode !== 409) return first;
+  try {
+    const u = new URL(url);
+    const segs = u.pathname.split('/').filter(Boolean);
+    segs.pop(); // 最后一段是文件名
+    let cur = u.origin;
+    for (const s of segs) {
+      cur += '/' + s;
+      await webdavRequest({ method: 'MKCOL', url: cur, ...auth, timeoutMs: 15000 });
+    }
+  } catch { /* URL 解析失败：直接重试原 PUT */ }
+  return webdavRequest({ method: 'PUT', url, uploadFile, ...auth, timeoutMs });
+}