codeksei 0.1.0

package/scripts/install-background-tasks.ps1

@@ -0,0 +1,135 @@
+param(
+  [int]$WatchdogMinutes = 5
+)
+
+$ErrorActionPreference = "Stop"
+
+if ($WatchdogMinutes -lt 1) {
+  throw "WatchdogMinutes 必须大于等于 1"
+}
+
+$runnerPath = Join-Path $PSScriptRoot "shared-task-runner.ps1"
+$currentUser = [System.Security.Principal.WindowsIdentity]::GetCurrent().Name
+$taskNames = @{
+  start = "Codeksei Shared Start"
+  unlock = "Codeksei Shared Unlock"
+  resume = "Codeksei Shared Resume"
+  watchdog = "Codeksei Shared Watchdog"
+}
+$legacyTaskNames = @(
+  "Cyberboss Shared Start",
+  "Cyberboss Shared Unlock",
+  "Cyberboss Shared Resume",
+  "Cyberboss Shared Watchdog"
+)
+
+function Escape-XmlText {
+  param([string]$Value)
+  [System.Security.SecurityElement]::Escape($Value)
+}
+
+function Register-CyberbossTaskXml {
+  param(
+    [string]$TaskName,
+    [string]$TriggerXml,
+    [string]$ArgumentsXml
+  )
+
+  $escapedUser = Escape-XmlText $currentUser
+  $taskXml = @"
+<?xml version="1.0" encoding="UTF-16"?>
+<Task version="1.3" xmlns="http://schemas.microsoft.com/windows/2004/02/mit/task">
+  <RegistrationInfo>
+    <URI>\$TaskName</URI>
+    <SecurityDescriptor></SecurityDescriptor>
+  </RegistrationInfo>
+  <Triggers>
+$TriggerXml
+  </Triggers>
+  <Principals>
+    <Principal id="Author">
+      <UserId>$escapedUser</UserId>
+      <LogonType>InteractiveToken</LogonType>
+      <RunLevel>LeastPrivilege</RunLevel>
+    </Principal>
+  </Principals>
+  <Settings>
+    <MultipleInstancesPolicy>IgnoreNew</MultipleInstancesPolicy>
+    <DisallowStartIfOnBatteries>false</DisallowStartIfOnBatteries>
+    <StopIfGoingOnBatteries>false</StopIfGoingOnBatteries>
+    <AllowHardTerminate>true</AllowHardTerminate>
+    <StartWhenAvailable>true</StartWhenAvailable>
+    <RunOnlyIfNetworkAvailable>false</RunOnlyIfNetworkAvailable>
+    <IdleSettings>
+      <Duration>PT10M</Duration>
+      <WaitTimeout>PT1H</WaitTimeout>
+      <StopOnIdleEnd>true</StopOnIdleEnd>
+      <RestartOnIdle>false</RestartOnIdle>
+    </IdleSettings>
+    <AllowStartOnDemand>true</AllowStartOnDemand>
+    <Enabled>true</Enabled>
+    <Hidden>false</Hidden>
+    <RunOnlyIfIdle>false</RunOnlyIfIdle>
+    <DisallowStartOnRemoteAppSession>false</DisallowStartOnRemoteAppSession>
+    <UseUnifiedSchedulingEngine>true</UseUnifiedSchedulingEngine>
+    <WakeToRun>false</WakeToRun>
+    <ExecutionTimeLimit>PT10M</ExecutionTimeLimit>
+    <Priority>7</Priority>
+  </Settings>
+  <Actions Context="Author">
+    <Exec>
+      <Command>powershell.exe</Command>
+      <Arguments>$ArgumentsXml</Arguments>
+    </Exec>
+  </Actions>
+</Task>
+"@
+
+  Register-ScheduledTask -TaskName $TaskName -Xml $taskXml -Force | Out-Null
+}
+
+foreach ($taskName in @($taskNames.start, $taskNames.unlock, $taskNames.resume, $taskNames.watchdog) + $legacyTaskNames) {
+  try {
+    Unregister-ScheduledTask -TaskName $taskName -Confirm:$false -ErrorAction Stop | Out-Null
+  } catch {
+    # best effort; task may not exist yet
+  }
+}
+
+$bootstrapArguments = Escape-XmlText "-NoProfile -ExecutionPolicy Bypass -WindowStyle Hidden -File `"$runnerPath`" -Mode Start -IntervalMinutes $WatchdogMinutes"
+$escapedUser = Escape-XmlText $currentUser
+$logonTriggerXml = @"
+    <LogonTrigger>
+      <Enabled>true</Enabled>
+      <UserId>$escapedUser</UserId>
+    </LogonTrigger>
+"@
+$unlockTriggerXml = @"
+    <SessionStateChangeTrigger>
+      <Enabled>true</Enabled>
+      <StateChange>SessionUnlock</StateChange>
+      <UserId>$escapedUser</UserId>
+    </SessionStateChangeTrigger>
+"@
+$resumeTriggerXml = @"
+    <EventTrigger>
+      <Enabled>true</Enabled>
+      <Subscription><![CDATA[<QueryList><Query Id="0" Path="System"><Select Path="System">*[System[Provider[@Name='Microsoft-Windows-Power-Troubleshooter'] and EventID=1]]</Select></Query></QueryList>]]></Subscription>
+    </EventTrigger>
+"@
+
+# Use short-lived event-driven bootstrap tasks instead of a periodic task.
+# The detached supervisor keeps idle checks quiet, while logon/unlock/resume
+# pokes recover quickly after session lifecycle changes without relaunching a
+# watchdog shell every few minutes.
+Register-CyberbossTaskXml -TaskName $taskNames.start -TriggerXml $logonTriggerXml -ArgumentsXml $bootstrapArguments
+Register-CyberbossTaskXml -TaskName $taskNames.unlock -TriggerXml $unlockTriggerXml -ArgumentsXml $bootstrapArguments
+Register-CyberbossTaskXml -TaskName $taskNames.resume -TriggerXml $resumeTriggerXml -ArgumentsXml $bootstrapArguments
+
+Start-ScheduledTask -TaskName $taskNames.start
+
+Write-Host "installed=$($taskNames.start)"
+Write-Host "installed=$($taskNames.unlock)"
+Write-Host "installed=$($taskNames.resume)"
+Write-Host "removed=$($taskNames.watchdog)"
+Write-Host "supervisor_interval_minutes=$WatchdogMinutes"

package/scripts/open_shared_wechat_thread.sh

@@ -0,0 +1,94 @@
+#!/bin/zsh
+set -euo pipefail
+
+ROOT_DIR="$(cd "$(dirname "$0")/.." && pwd)"
+PORT="${CODEKSEI_SHARED_PORT:-${CYBERBOSS_SHARED_PORT:-8765}}"
+REMOTE_URL="ws://127.0.0.1:${PORT}"
+STATE_DIR="${CODEKSEI_STATE_DIR:-${CYBERBOSS_STATE_DIR:-$HOME/.codeksei}}"
+if [[ ! -d "${STATE_DIR}" && -d "$HOME/.cyberboss" ]]; then
+  STATE_DIR="$HOME/.cyberboss"
+fi
+LOG_DIR="${STATE_DIR}/logs"
+PID_FILE="${LOG_DIR}/shared-wechat.pid"
+
+mkdir -p "${LOG_DIR}"
+
+function resolve_pid_cwd() {
+  local pid="$1"
+  lsof -a -p "${pid}" -d cwd -Fn 2>/dev/null | sed -n 's/^n//p' | head -n 1
+}
+
+function list_bridge_processes() {
+  ps -ax -o pid=,ppid=,command= | awk '/node \.\/bin\/(codeksei|cyberboss)\.js start --checkin/ { print }'
+}
+
+function find_bridge_child_pid() {
+  local parent_pid="$1"
+  list_bridge_processes | awk -v target_ppid="${parent_pid}" '$2 == target_ppid { print $1; exit }'
+}
+
+function resolve_bridge_pid() {
+  local candidate_pid="$1"
+  [[ -n "${candidate_pid}" ]] || return 1
+  if ! kill -0 "${candidate_pid}" 2>/dev/null; then
+    return 1
+  fi
+
+  local child_pid
+  child_pid="$(find_bridge_child_pid "${candidate_pid}")"
+  if [[ -n "${child_pid}" ]]; then
+    echo "${child_pid}"
+    return 0
+  fi
+
+  if [[ "$(resolve_pid_cwd "${candidate_pid}")" == "${ROOT_DIR}" ]]; then
+    echo "${candidate_pid}"
+    return 0
+  fi
+
+  return 1
+}
+
+function find_existing_bridge_pid() {
+  if [[ -f "${PID_FILE}" ]]; then
+    local pid_from_file
+    pid_from_file="$(cat "${PID_FILE}" 2>/dev/null || true)"
+    local resolved_from_file
+    resolved_from_file="$(resolve_bridge_pid "${pid_from_file}" || true)"
+    if [[ -n "${resolved_from_file}" ]]; then
+      echo "${resolved_from_file}"
+      return 0
+    fi
+  fi
+
+  local pid
+  while read -r pid _; do
+    [[ -n "${pid}" ]] || continue
+    if [[ "$(resolve_pid_cwd "${pid}")" == "${ROOT_DIR}" ]]; then
+      echo "${pid}"
+      return 0
+    fi
+  done < <(list_bridge_processes)
+
+  return 1
+}
+
+"${ROOT_DIR}/scripts/start_shared_app_server.sh"
+
+EXISTING_PID="$(find_existing_bridge_pid || true)"
+
+if [[ -z "${EXISTING_PID}" ]]; then
+  echo "shared codeksei is not running." >&2
+  echo "start it in a separate terminal and keep it in the foreground:" >&2
+  echo "  cd ${ROOT_DIR}" >&2
+  echo "  ./scripts/start_shared_wechat.sh" >&2
+  exit 1
+fi
+
+echo "${EXISTING_PID}" > "${PID_FILE}"
+
+echo "shared codeksei running pid=${EXISTING_PID} endpoint=${REMOTE_URL}"
+
+export CODEKSEI_CODEX_ENDPOINT="${REMOTE_URL}"
+export CYBERBOSS_CODEX_ENDPOINT="${REMOTE_URL}"
+exec "${ROOT_DIR}/scripts/open_wechat_thread.sh" "$@"

package/scripts/open_wechat_thread.sh

@@ -0,0 +1,117 @@
+#!/bin/zsh
+set -euo pipefail
+
+PORT="${CODEKSEI_SHARED_PORT:-${CYBERBOSS_SHARED_PORT:-8765}}"
+REMOTE_URL="${CODEKSEI_CODEX_ENDPOINT:-${CYBERBOSS_CODEX_ENDPOINT:-ws://127.0.0.1:${PORT}}}"
+STATE_DIR="${CODEKSEI_STATE_DIR:-${CYBERBOSS_STATE_DIR:-$HOME/.codeksei}}"
+if [[ ! -d "${STATE_DIR}" && -d "$HOME/.cyberboss" ]]; then
+  STATE_DIR="$HOME/.cyberboss"
+fi
+SESSION_FILE="${CODEKSEI_SESSIONS_FILE:-${CYBERBOSS_SESSIONS_FILE:-${STATE_DIR}/sessions.json}}"
+WORKSPACE_ROOT="${CODEKSEI_WORKSPACE_ROOT:-${CYBERBOSS_WORKSPACE_ROOT:-$PWD}}"
+ACCOUNT_DIR="${STATE_DIR}/accounts"
+
+if [[ ! -f "${SESSION_FILE}" ]]; then
+  echo "session file not found: ${SESSION_FILE}" >&2
+  exit 1
+fi
+
+RESOLVED="$(
+  node -e '
+    const fs = require("fs");
+    const path = require("path");
+
+    const sessionFile = process.argv[1];
+    const workspaceRoot = process.argv[2];
+    const accountDir = process.argv[3];
+    const data = JSON.parse(fs.readFileSync(sessionFile, "utf8"));
+    const bindings = Object.entries(data.bindings || {}).map(([bindingKey, binding]) => ({ bindingKey, ...(binding || {}) }));
+
+    function normalize(value) {
+      return typeof value === "string" ? value.trim() : "";
+    }
+
+    function toTimestamp(value) {
+      const parsed = Date.parse(normalize(value));
+      return Number.isFinite(parsed) ? parsed : 0;
+    }
+
+    function resolveCurrentAccountId(dir) {
+      const normalizedDir = normalize(dir);
+      if (!normalizedDir || !fs.existsSync(normalizedDir)) {
+        return "";
+      }
+
+      const entries = fs.readdirSync(normalizedDir)
+        .filter((name) => name.endsWith(".json") && !name.endsWith(".context-tokens.json"))
+        .map((name) => {
+          const fullPath = path.join(normalizedDir, name);
+          try {
+            const parsed = JSON.parse(fs.readFileSync(fullPath, "utf8"));
+            return {
+              accountId: normalize(parsed && parsed.accountId),
+              savedAt: toTimestamp(parsed && parsed.savedAt),
+            };
+          } catch {
+            return null;
+          }
+        })
+        .filter(Boolean)
+        .filter((entry) => entry.accountId);
+
+      entries.sort((left, right) => right.savedAt - left.savedAt);
+      return entries[0]?.accountId || "";
+    }
+
+    function getThreadId(binding, root) {
+      const normalizedRoot = normalize(root);
+      if (!normalizedRoot) {
+        return "";
+      }
+      const map = binding && typeof binding.threadIdByWorkspaceRoot === "object"
+        ? binding.threadIdByWorkspaceRoot
+        : {};
+      return normalize(map[normalizedRoot]);
+    }
+
+    const normalizedWorkspaceRoot = normalize(workspaceRoot);
+    const currentAccountId = resolveCurrentAccountId(accountDir);
+
+    const filteredBindings = bindings
+      .filter((binding) => !currentAccountId || normalize(binding.accountId) === currentAccountId)
+      .sort((left, right) => toTimestamp(right.updatedAt) - toTimestamp(left.updatedAt));
+
+    const exactBinding = filteredBindings.find((binding) => getThreadId(binding, normalizedWorkspaceRoot));
+    if (exactBinding) {
+      process.stdout.write(`${getThreadId(exactBinding, normalizedWorkspaceRoot)}\n${normalizedWorkspaceRoot}`);
+      process.exit(0);
+    }
+
+    const activeBinding = filteredBindings.find((binding) => {
+      const activeWorkspaceRoot = normalize(binding && binding.activeWorkspaceRoot);
+      return activeWorkspaceRoot && getThreadId(binding, activeWorkspaceRoot);
+    });
+    if (activeBinding) {
+      const activeWorkspaceRoot = normalize(activeBinding.activeWorkspaceRoot);
+      process.stdout.write(`${getThreadId(activeBinding, activeWorkspaceRoot)}\n${activeWorkspaceRoot}`);
+      process.exit(0);
+    }
+
+    process.exit(1);
+  ' "${SESSION_FILE}" "${WORKSPACE_ROOT}" "${ACCOUNT_DIR}"
+)"
+
+if [[ -z "${RESOLVED}" ]]; then
+  echo "no bound WeChat thread found for workspace: ${WORKSPACE_ROOT}" >&2
+  exit 1
+fi
+
+THREAD_ID="${RESOLVED%%$'\n'*}"
+RESOLVED_WORKSPACE_ROOT="${RESOLVED#*$'\n'}"
+
+if [[ -z "${THREAD_ID}" || -z "${RESOLVED_WORKSPACE_ROOT}" ]]; then
+  echo "failed to resolve bound WeChat thread from: ${SESSION_FILE}" >&2
+  exit 1
+fi
+
+exec codex resume "${THREAD_ID}" --remote "${REMOTE_URL}" -C "${RESOLVED_WORKSPACE_ROOT}" "$@"