@cnkang/qdrant-memory-launcher 0.0.0-stage → 0.1.0-rc.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Kang Liu
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,86 @@
-# Temporary Holding Version
+# Managed Qdrant Memory launcher
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+The launcher installs a private Python environment, Runtime 0.3.0 and a
+verified multilingual CPU embedding model. WorkBuddy and DeepSeek Harness use
+separate embedded memory profiles. Existing Hermes installations keep their
+configuration and data.
+
+This is a release candidate. Marketplace installation and desktop acceptance
+are tracked separately for each operating system.
+
+## Install and prepare
+
+For a client that already supplies Node.js 20 or newer:
+
+```sh
+npm install --global @cnkang/qdrant-memory-launcher@0.1.0-rc.2
+qdrant-memory-launcher prepare dsh
+qdrant-memory-launcher mcp dsh
+```
+
+Preparation needs network access and may take several minutes. It downloads
+private Python dependencies and about 252 MB of model artifacts. No system
+Python, uv/uvx, Ollama or Qdrant Server is required. The local preset needs no
+API keys. DSH must finish preparation before you enable the MCP connection.
+Its temporary MCP probe never runs installation.
+
+WorkBuddy's managed Connector declares Node.js 20 and requires WorkBuddy
+5.0.0 or newer. It runs `mcp workbuddy --auto-setup`. Installing that connection
+authorizes downloads and creation of its private profile.
+
+## First connection and recovery
+
+The four tools appear while preparation runs. A connection indicator means the
+MCP transport is available. It does not mean the memory backend is ready.
+During preparation, tool calls report that no operation occurred. Wait before
+asking the agent to save a fact. Writes are never queued.
+
+After an ordinary network interruption, check the connection and available disk
+space, then disconnect and reconnect WorkBuddy to retry. DSH users should run
+`qdrant-memory-launcher prepare dsh` again before reconnecting. A failed setup
+does not reset memory data. Preparation does not retry downloads indefinitely.
+
+If a save, update or delete was interrupted after dispatch, search for the
+affected memory and check its ID before repeating it. Reconnection never
+automatically repeats a write.
+
+A busy-profile error means another process owns that profile. Close that
+connection normally. Never remove data locks to force a second writer.
+
+## Storage and upgrades
+
+The default root is `qdrant-memory-managed` under:
+
+| System | Data directory |
+| --- | --- |
+| macOS | `~/Library/Application Support` |
+| Windows | `%LOCALAPPDATA%` |
+| Linux | `$XDG_DATA_HOME` or `~/.local/share` |
+
+Program environments live under `programs/`, models under `models/`, and
+host data under `profiles/workbuddy/local/` or `profiles/dsh/local/`.
+The optional `QDRANT_MEMORY_MANAGED_ROOT` must be an absolute path.
+Program versions and dependency locks select separate installation directories.
+Existing profiles retain their model-cache settings during an upgrade.
+
+Disconnect the client before upgrading or using maintenance commands.
+Uninstalling the npm package removes the launcher. It does not remove profiles
+or models. Back up the profile before a rollback and retain the same embedding
+pipeline. Do not copy a running embedded store or automatically migrate it.
+
+After an unexpected OS shutdown or force-killed installation, a provisioning
+lock may require operator assistance. Confirm that the installer and its child
+processes have stopped before inspecting only that program's
+`.provision.lock`. Do not remove profile files or Runtime data locks.
+
+## Package integrity
+
+The launcher contains no third-party JavaScript dependencies or downloaded
+models. It verifies bootstrap and public Runtime wheel bytes before execution.
+All Python dependencies are pinned with hashes and installed as wheels, with
+no source builds. Runtime verifies the model revision and artifacts.
+
+`runtime.json`, `requirements.lock` and `bootstrap.mjs` record the exact
+versions and integrity checks. See [third-party notices](THIRD_PARTY_NOTICES.md).
+Installer subprocesses receive a restricted environment without service keys.
+MCP stdout carries only protocol messages.

package/THIRD_PARTY_NOTICES.md

@@ -0,0 +1,17 @@
+# Third-party notices
+
+The launcher is MIT-licensed. It contains no third-party JavaScript dependencies.
+It downloads the following components into a private installation directory:
+
+| Component | License |
+| --- | --- |
+| uv | Apache-2.0 OR MIT |
+| Python (python-build-standalone) | PSF-2.0 |
+| Qdrant Memory Runtime | MIT |
+| CPU embedding model, Qdrant/paraphrase-multilingual-MiniLM-L12-v2-onnx-Q | Apache-2.0 |
+
+Versions, download locations and artifact hashes are recorded in
+`bootstrap.mjs`, `runtime.json` and `requirements.lock`. Runtime verifies the
+model revision and artifact hashes. Downloaded dependencies retain their
+upstream licenses in the private Python environment. This package does not
+contain Python, uv, model weights, user profiles or memory data.

package/bootstrap.mjs

@@ -0,0 +1,196 @@
+/** Prerequisite PoC: verified managed Python using only Node and OS facilities.
+ * This is not the production WorkBuddy launcher and does not initialize memory.
+ */
+import { createHash } from 'node:crypto';
+import { spawnSync } from 'node:child_process';
+import { mkdtemp, mkdir, realpath, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join, relative, isAbsolute } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { inflateRawSync } from 'node:zlib';
+
+export const UV_VERSION = '0.13.1';
+export const PYTHON_VERSION = '3.11.15';
+// Official PyPI uv wheels. The entire artifact is checked before ZIP parsing.
+export const BOOTSTRAPS = {
+  'darwin-arm64': {
+    url: 'https://files.pythonhosted.org/packages/3b/31/fad7fd2ac81954d02d33765bf8535eb320fcc2d71f2603a5c1ba0b13b8ef/uv-0.13.1-py3-none-macosx_11_0_arm64.whl',
+    sha256: 'cfa719fbbd23f26713394dea2692b7f146aa1b5713ce5e776e878701214ea52c', size: 14391237,
+  },
+  'darwin-x64': {
+    url: 'https://files.pythonhosted.org/packages/db/3d/6ac43d7a15be1d589aae1e15289507f5ccebeac14f28c37882058f2474a3/uv-0.13.1-py3-none-macosx_10_12_x86_64.whl',
+    sha256: '7e60223e3e9636a3734d6c11b3552aeed987c40f1ca2497a546af58f2f883d56', size: 17663254,
+  },
+  'linux-x64': {
+    url: 'https://files.pythonhosted.org/packages/14/0b/6602a613533602e7a083e908c4375f9b0e78a94ba2e21c29b21c41a0a611/uv-0.13.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl',
+    sha256: '696dcf6d807d85da978f4db8472da81dccc1254b18b52cbd1367c4d923c421e0', size: 17279385,
+  },
+  'win32-x64': {
+    url: 'https://files.pythonhosted.org/packages/2a/8e/d23278bb327d2a75dc1d033c81b7fe23bbb28e363e02e7f306abd047924a/uv-0.13.1-py3-none-win_amd64.whl',
+    sha256: '4f693cd4feb52f08f30474c4612f24be2050472609be65b9960b635f286da284', size: 15404994,
+  },
+};
+
+export function verifyArtifact(bytes, spec) {
+  if (bytes.length !== spec.size || createHash('sha256').update(bytes).digest('hex') !== spec.sha256) {
+    throw new Error('Bootstrap artifact integrity mismatch');
+  }
+  return bytes;
+}
+
+function bounds(bytes, offset, size) {
+  if (!Number.isSafeInteger(offset) || offset < 0 || size < 0 || offset + size > bytes.length) {
+    throw new Error('Invalid ZIP bounds');
+  }
+}
+
+export function extractExecutable(bytes, expectedName) {
+  // Read one regular file into memory. No archive paths are written to disk.
+  let end = -1;
+  for (let cursor = bytes.length - 22; cursor >= Math.max(0, bytes.length - 65557); cursor--) {
+    if (bytes.readUInt32LE(cursor) === 0x06054b50) { end = cursor; break; }
+  }
+  if (end < 0) throw new Error('ZIP end record missing');
+  const count = bytes.readUInt16LE(end + 10);
+  const centralSize = bytes.readUInt32LE(end + 12);
+  let cursor = bytes.readUInt32LE(end + 16);
+  bounds(bytes, cursor, centralSize);
+  if (!count || count > 1000 || bytes.readUInt16LE(end + 4) || bytes.readUInt16LE(end + 6)
+      || bytes.readUInt16LE(end + 8) !== count || cursor + centralSize !== end) {
+    throw new Error('Unsupported ZIP layout');
+  }
+  let executable;
+  for (let index = 0; index < count; index++) {
+    bounds(bytes, cursor, 46);
+    if (bytes.readUInt32LE(cursor) !== 0x02014b50) throw new Error('Invalid ZIP directory');
+    const flags = bytes.readUInt16LE(cursor + 8);
+    const method = bytes.readUInt16LE(cursor + 10);
+    const compressed = bytes.readUInt32LE(cursor + 20);
+    const expanded = bytes.readUInt32LE(cursor + 24);
+    const nameSize = bytes.readUInt16LE(cursor + 28);
+    const extraSize = bytes.readUInt16LE(cursor + 30);
+    const commentSize = bytes.readUInt16LE(cursor + 32);
+    const mode = bytes.readUInt32LE(cursor + 38) >>> 16;
+    const localOffset = bytes.readUInt32LE(cursor + 42);
+    bounds(bytes, cursor + 46, nameSize + extraSize + commentSize);
+    const name = bytes.subarray(cursor + 46, cursor + 46 + nameSize).toString('utf8');
+    if (name.startsWith('/') || /^[A-Za-z]:/.test(name) || name.includes('\\') || name.includes('\0')
+        || name.split('/').includes('..') || (mode & 0xf000) === 0xa000 || flags & 1) {
+      throw new Error('Unsafe ZIP member');
+    }
+    if (name === expectedName) {
+      if (executable || ![0, 0x8000].includes(mode & 0xf000) || ![0, 8].includes(method)
+          || expanded > 64 * 1024 * 1024) throw new Error('Invalid executable entry');
+      bounds(bytes, localOffset, 30);
+      if (bytes.readUInt32LE(localOffset) !== 0x04034b50
+          || bytes.readUInt16LE(localOffset + 6) !== flags
+          || bytes.readUInt16LE(localOffset + 8) !== method) throw new Error('Invalid ZIP local header');
+      const localNameSize = bytes.readUInt16LE(localOffset + 26);
+      const localExtraSize = bytes.readUInt16LE(localOffset + 28);
+      bounds(bytes, localOffset + 30, localNameSize + localExtraSize + compressed);
+      if (bytes.subarray(localOffset + 30, localOffset + 30 + localNameSize).toString('utf8') !== name) {
+        throw new Error('ZIP local path mismatch');
+      }
+      const start = localOffset + 30 + localNameSize + localExtraSize;
+      const content = bytes.subarray(start, start + compressed);
+      executable = method === 0 ? content : inflateRawSync(content, { maxOutputLength: 64 * 1024 * 1024 });
+      if (executable.length !== expanded) throw new Error('Invalid executable size');
+    }
+    cursor += 46 + nameSize + extraSize + commentSize;
+  }
+  if (!executable) throw new Error('Bootstrap executable missing');
+  return executable;
+}
+
+export function anySignal(signals) {
+  // Node 20.0-20.2 lack AbortSignal.any; this keeps the declared >=20 floor valid.
+  if (signals.length === 1) return signals[0];
+  const controller = new AbortController();
+  for (const source of signals) {
+    if (source.aborted) { controller.abort(source.reason); return controller.signal; }
+    source.addEventListener('abort', () => controller.abort(source.reason), { once: true });
+  }
+  return controller.signal;
+}
+
+export async function download(spec, signal) {
+  const timeout = AbortSignal.timeout(120000);
+  const response = await fetch(spec.url, { redirect: 'error', signal: signal ? anySignal([signal, timeout]) : timeout });
+  if (!response.ok) throw new Error('Bootstrap download failed');
+  const blocks = [];
+  let length = 0;
+  for await (const chunk of response.body) {
+    length += chunk.length;
+    if (length > spec.size) throw new Error('Bootstrap download exceeded its pinned size');
+    blocks.push(chunk);
+  }
+  return verifyArtifact(Buffer.concat(blocks), spec);
+}
+
+function failureCategory(result) {
+  // Inspect subprocess details only in memory; expose allowlisted labels, never stderr.
+  const diagnostic = `${result.error?.code ?? ''}\n${result.stderr ?? ''}`;
+  return [
+    ['timeout', /ETIMEDOUT|timed? out/i],
+    ['certificate', /certificate|UnknownIssuer|\bTLS\b|\bSSL\b/i],
+    ['permission', /EACCES|EPERM|permission denied|access is denied/i],
+    ['platform', /ENOEXEC|ENOENT|exec format|unsupported platform|no download found/i],
+    ['network', /ENOTFOUND|ECONN|EAI_AGAIN|network|connection|DNS|lookup address/i],
+  ].find(([, pattern]) => pattern.test(diagnostic))?.[0] ?? 'subprocess';
+}
+
+export function command(executable, args, env, timeout) {
+  const result = spawnSync(executable, args, { env, timeout, encoding: 'utf8', windowsHide: true });
+  if (result.status !== 0 || result.error) {
+    const error = new Error('Managed Python bootstrap command failed');
+    error.stage = args[0] === 'python' ? `python-${args[1]}` : 'python-execute';
+    error.exitCode = result.status;
+    error.category = failureCategory(result);
+    throw error;
+  }
+  return result.stdout.trim();
+}
+
+export async function probeManagedPython() {
+  const spec = BOOTSTRAPS[`${process.platform}-${process.arch}`];
+  if (!spec) throw new Error('This platform has no verified bootstrap artifact');
+  const started = performance.now();
+  const root = await realpath(await mkdtemp(join(tmpdir(), 'qdrant-managed-python-')));
+  const emptyPath = join(root, 'empty-path');
+  await mkdir(emptyPath);
+  const uv = join(root, process.platform === 'win32' ? 'uv.exe' : 'uv');
+  const name = `uv-${UV_VERSION}.data/scripts/${process.platform === 'win32' ? 'uv.exe' : 'uv'}`;
+  const executable = extractExecutable(await download(spec), name);
+  await writeFile(uv, executable, { flag: 'wx', mode: 0o700 });
+  const env = {
+    PATH: emptyPath, UV_CACHE_DIR: join(root, 'cache'), UV_PYTHON_INSTALL_DIR: join(root, 'python'),
+    UV_PYTHON_PREFERENCE: 'only-managed', UV_NO_CONFIG: '1',
+  };
+  for (const key of ['SYSTEMROOT', 'WINDIR', 'TEMP', 'TMP']) {
+    if (process.env[key]) env[key] = process.env[key];
+  }
+  command(uv, ['python', 'install', PYTHON_VERSION, '--no-bin'], env, 180000);
+  const python = command(uv, ['python', 'find', '--system', PYTHON_VERSION], env, 10000);
+  const inside = relative(root, python);
+  if (!inside || inside.startsWith('..') || isAbsolute(inside)) throw new Error('Python escaped the fresh managed root');
+  const version = command(python, ['-I', '-c', 'import sys; print(sys.version.split()[0])'], env, 10000);
+  if (version !== PYTHON_VERSION) throw new Error('Unexpected Python version');
+  return { platform: process.platform, architecture: process.arch, bootstrap_sha256_verified: true,
+    system_tools_on_path: false, fresh_managed_python: true, python_version: version,
+    elapsed_seconds: Number(((performance.now() - started) / 1000).toFixed(3)) };
+}
+
+if (process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url) {
+  if (process.argv.length !== 3 || process.argv[2] !== '--probe') {
+    console.error('Usage: node integrations/managed/bootstrap.mjs --probe');
+    process.exitCode = 2;
+  } else {
+    try { console.log(JSON.stringify(await probeManagedPython())); }
+    catch (error) {
+      console.error(JSON.stringify({ error: 'Managed Python probe failed; no memory profile was modified.',
+        stage: error.stage || 'download-or-verification', exit_code: error.exitCode ?? null,
+        category: error.category || 'bootstrap' }));
+      process.exitCode = 1;
+    }
+  }
+}

package/bridge.mjs

@@ -0,0 +1,134 @@
+/** Small stdio readiness boundary; Runtime remains the only tool implementation. */
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { readFile } from 'node:fs/promises';
+import { isDeepStrictEqual } from 'node:util';
+
+export const tools = JSON.parse(await readFile(new URL('./tools.json', import.meta.url), 'utf8'));
+const { version } = JSON.parse(await readFile(new URL('./package.json', import.meta.url), 'utf8'));
+const launcherVersion = version;
+const failure = text => ({ content: [{ type: 'text', text }], isError: true });
+
+export async function bridge(startBackend, input = process.stdin, output = process.stdout) {
+  const abort = new AbortController();
+  const pending = new Map();
+  let backend, ready = false, closed = false, sequence = 0, initialized = false;
+  let state = 'Preparing memory. No operation was performed; retry when preparation finishes.';
+  const send = message => { if (!closed) output.write(JSON.stringify({ jsonrpc: '2.0', ...message }) + '\n'); };
+  const wire = message => backend.stdin.write(JSON.stringify({ jsonrpc: '2.0', ...message }) + '\n');
+  let finish;
+  const done = new Promise(resolve => { finish = resolve; });
+  const shutdown = () => {
+    if (closed) return;
+    closed = true;
+    abort.abort();
+    if (backend && backend.exitCode === null && backend.signalCode === null) {
+      backend.stdin.end();
+      // Allow Runtime to close storage/lease normally before SDK-style escalation.
+      const term = setTimeout(() => backend.kill('SIGTERM'), 3000);
+      const kill = setTimeout(() => backend.kill('SIGKILL'), 6000);
+      backend.once('close', () => { clearTimeout(term); clearTimeout(kill); });
+    }
+    finish();
+  };
+  const lines = createInterface({ input, crlfDelay: Infinity });
+  const onSignal = () => { lines.close(); shutdown(); };
+  process.once('SIGTERM', onSignal);
+  process.once('SIGINT', onSignal);
+  lines.on('close', shutdown);
+  lines.on('line', line => {
+    if (closed) return;
+    let message;
+    try { message = JSON.parse(line); } catch { send({ id: null, error: { code: -32700, message: 'Parse error' } }); return; }
+    if (!message || typeof message !== 'object' || Array.isArray(message) || message.jsonrpc !== '2.0') {
+      send({ id: null, error: { code: -32600, message: 'Invalid request' } }); return;
+    }
+    const hasId = Object.hasOwn(message, 'id');
+    if (!hasId) {
+      if (ready && message.method === 'notifications/cancelled') {
+        const entry = [...pending].find(([, id]) => id === message.params?.requestId);
+        if (entry) wire({ method: message.method, params: { ...message.params, requestId: entry[0] } });
+      }
+      return;
+    }
+    const { id, method } = message;
+    if ((typeof id !== 'string' && (typeof id !== 'number' || !Number.isSafeInteger(id)))
+        || typeof method !== 'string') {
+      send({ id: null, error: { code: -32600, message: 'Invalid request' } });
+      return;
+    }
+    if (method === 'initialize') {
+      initialized = true;
+      const version = message.params?.protocolVersion;
+      send({ id, result: { protocolVersion: ['2024-11-05', '2025-03-26', '2025-06-18', '2025-11-25'].includes(version) ? version : '2025-11-25',
+        capabilities: { tools: {} }, serverInfo: { name: 'qdrant-memory-managed', version: launcherVersion } } });
+    } else if (method === 'ping') send({ id, result: {} });
+    else if (!initialized) send({ id, error: { code: -32000, message: 'Initialize first' } });
+    else if (method === 'tools/list') send({ id, result: { tools } });
+    else if (method === 'tools/call') {
+      if (!ready) send({ id, result: failure(state) });
+      else {
+        const internal = ++sequence;
+        pending.set(internal, id);
+        wire({ id: internal, method, params: message.params });
+      }
+    } else send({ id, error: { code: -32601, message: 'Method not found' } });
+  });
+  void (async () => {
+    try {
+      const command = await startBackend(abort.signal);
+      if (closed) return;
+      backend = spawn(command.command, command.args, { env: command.env, windowsHide: true, stdio: ['pipe', 'pipe', 'ignore'] });
+      const failed = () => {
+        ready = false;
+        state = 'Memory backend stopped. No automatic write retry was performed; reconnect and search before retrying a write.';
+        for (const id of pending.values()) send({ id, result: failure(state) });
+        pending.clear();
+        // Closing the transport lets the host's own reconnect/backoff policy act.
+        // Never leave a live bridge that masks a dead Runtime indefinitely.
+        lines.close();
+        shutdown();
+      };
+      backend.on('error', failed);
+      backend.on('close', failed);
+      backend.stdin.on('error', failed);
+      const responses = createInterface({ input: backend.stdout, crlfDelay: Infinity });
+      responses.on('line', line => {
+        let message;
+        try { message = JSON.parse(line); } catch { failed(); backend.kill(); return; }
+        if (!message || typeof message !== 'object' || Array.isArray(message)
+            || message.jsonrpc !== '2.0') { failed(); return; }
+        // Runtime notifications have no response ID. Only a valid response may
+        // complete an initialization or a dispatched operation.
+        if (!Object.hasOwn(message, 'id')) {
+          if (typeof message.method !== 'string' || Object.hasOwn(message, 'result') || Object.hasOwn(message, 'error')) failed();
+          return;
+        }
+        if (Object.hasOwn(message, 'result') === Object.hasOwn(message, 'error')) {
+          failed(); return;
+        }
+        if (message.id === 'init') {
+          if (!message.result) { failed(); return; }
+          wire({ method: 'notifications/initialized' });
+          wire({ id: 'catalogue', method: 'tools/list', params: {} });
+        } else if (message.id === 'catalogue') {
+          if (!isDeepStrictEqual(message.result?.tools, tools)) { failed(); backend.kill(); return; }
+          ready = true;
+        } else if (pending.has(message.id)) {
+          const id = pending.get(message.id);
+          pending.delete(message.id);
+          send({ ...message, id });
+        } else failed();
+      });
+      backend.once('spawn', () => wire({ id: 'init', method: 'initialize', params: {
+        protocolVersion: '2025-11-25', capabilities: {}, clientInfo: { name: 'managed-launcher', version } } }));
+    } catch (error) {
+      const stage = ['inspect-installation', 'download-bootstrap', 'install-python', 'download-runtime', 'install-build-tools', 'install-runtime', 'setup-profile'].includes(error.stage)
+        ? ` (${error.stage})` : '';
+      state = `Memory preparation failed${stage}. No operation was performed. Check network and disk access, then disconnect and reconnect to retry preparation. DSH requires its prepare step before reconnecting.`;
+    }
+  })();
+  await done;
+  process.removeListener('SIGTERM', onSignal);
+  process.removeListener('SIGINT', onSignal);
+}

package/launcher.mjs

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+import { pathToFileURL } from 'node:url';
+import { realpath } from 'node:fs/promises';
+import { bridge } from './bridge.mjs';
+import { locations, installed, prepare } from './provision.mjs';
+
+export async function main(args) {
+  const [mode, host, ...rest] = args;
+  if (!['prepare', 'mcp'].includes(mode) || !host || rest.some(x => x !== '--auto-setup')
+      || (rest.length && (mode !== 'mcp' || host !== 'workbuddy')) || rest.length > 1) {
+    throw new Error('Usage: launcher.mjs prepare|mcp workbuddy|dsh [--auto-setup (WorkBuddy only)]');
+  }
+  const paths = locations(host);
+  if (mode === 'prepare') {
+    const controller = new AbortController();
+    const stop = () => controller.abort();
+    process.once('SIGTERM', stop);
+    process.once('SIGINT', stop);
+    try { await prepare(paths, host, controller.signal); }
+    finally { process.removeListener('SIGTERM', stop); process.removeListener('SIGINT', stop); }
+    console.log(JSON.stringify({ ready: true, host }));
+  } else {
+    await bridge(async signal => ({
+      command: rest.includes('--auto-setup') ? await prepare(paths, host, signal) : await installed(paths),
+      args: ['--home', paths.profile, 'mcp'],
+      env: { ...process.env, PYTHONNOUSERSITE: '1', PYTHONPATH: '', PYTHONHOME: '' },
+    }));
+  }
+}
+
+if (process.argv[1] && pathToFileURL(await realpath(process.argv[1])).href === import.meta.url) {
+  main(process.argv.slice(2)).catch(error => {
+    // Keep the message bounded: only the internal stage label may be added.
+    const stage = error && typeof error.stage === 'string' && /^[a-z][a-z-]*$/.test(error.stage) ? ` Failed stage: ${error.stage}.` : '';
+    console.error(`Qdrant Memory launcher failed. Check command, preparation, network, disk space and profile ownership. No profile was reset.${stage}`);
+    process.exitCode = 1;
+  });
+}

package/package.json

@@ -1,6 +1,13 @@
 {
   "name": "@cnkang/qdrant-memory-launcher",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0-rc.2",
+  "private": false,
+  "type": "module",
+  "description": "Private Python and CPU memory runtime for MCP clients",
+  "engines": {"node": ">=20"},
+  "bin": {"qdrant-memory-launcher": "launcher.mjs"},
+  "files": ["launcher.mjs", "provision.mjs", "bridge.mjs", "bootstrap.mjs", "tools.json", "runtime.json", "requirements.in", "requirements.lock", "README.md", "LICENSE", "THIRD_PARTY_NOTICES.md"],
+  "license": "MIT",
+  "repository": {"type": "git", "url": "git+https://github.com/cnkang/qdrant-memory-mcp.git", "directory": "integrations/managed"},
+  "publishConfig": {"access": "public", "registry": "https://registry.npmjs.org"}
+}