kimaki 0.21.0 → 0.23.0

package/dist/anthropic-auth-plugin.js

@@ -24,7 +24,7 @@
  */
 import { appendToastSessionMarker } from "./plugin-logger.js";
 import { createPluginClient } from "./plugin-opencode-client.js";
-import { loadAccountStore, rememberAnthropicOAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
+import { isPermanentOAuthRefreshFailure, loadAccountStore, rememberAnthropicOAuth, removeAccountByAuth, rotateAnthropicAccount, saveAccountStore, setAnthropicAuth, shouldRotateAuth, upsertAccount, withAuthStateLock, } from "./anthropic-auth-state.js";
 import { extractAnthropicAccountIdentity, } from "./anthropic-account-identity.js";
 // PKCE (Proof Key for Code Exchange) using Web Crypto API.
 // Reference: https://github.com/badlogic/pi-mono/blob/main/packages/ai/src/utils/oauth/pkce.ts
@@ -723,45 +723,86 @@ function mergeBetas(existing, required) {
 function isOAuthStored(auth) {
     return auth.type === "oauth";
 }
-async function getFreshOAuth(getAuth, client) {
+/**
+ * Refresh Anthropic OAuth. On permanent refresh failure (invalid_grant),
+ * remove that account from the pool and retry with the next one.
+ * removeAccountByAuth runs outside withAuthStateLock to avoid nested locks.
+ */
+async function getFreshOAuth(getAuth, client, options) {
     const auth = await getAuth();
     if (!isOAuthStored(auth))
         return undefined;
     if (auth.access && auth.expires > Date.now())
         return auth;
     const pending = pendingRefresh.get(auth.refresh);
-    if (pending) {
+    if (pending)
         return pending;
-    }
-    const refreshPromise = withAuthStateLock(async () => {
-        const latest = await getAuth();
-        if (!isOAuthStored(latest)) {
-            throw new Error("Anthropic OAuth credentials disappeared during refresh");
-        }
-        if (latest.access && latest.expires > Date.now())
-            return latest;
-        const refreshed = await refreshAnthropicToken(latest.refresh);
-        await setAnthropicAuth(refreshed, client);
-        const store = await loadAccountStore();
-        if (store.accounts.length > 0) {
-            const identity = (() => {
-                const currentIndex = store.accounts.findIndex((account) => {
-                    return (account.refresh === latest.refresh ||
-                        account.access === latest.access);
+    const refreshPromise = (async () => {
+        const attempted = new Set();
+        while (true) {
+            let failedAuth;
+            try {
+                return await withAuthStateLock(async () => {
+                    const latest = await getAuth();
+                    if (!isOAuthStored(latest)) {
+                        throw new Error("Anthropic OAuth credentials disappeared during refresh");
+                    }
+                    if (latest.access && latest.expires > Date.now())
+                        return latest;
+                    if (attempted.has(latest.refresh)) {
+                        throw new Error("Anthropic OAuth refresh failed for all remaining accounts");
+                    }
+                    attempted.add(latest.refresh);
+                    try {
+                        const refreshed = await refreshAnthropicToken(latest.refresh);
+                        await setAnthropicAuth(refreshed, client);
+                        const store = await loadAccountStore();
+                        if (store.accounts.length > 0) {
+                            const current = store.accounts.find((account) => account.refresh === latest.refresh ||
+                                account.access === latest.access);
+                            const identity = current
+                                ? {
+                                    ...(current.email ? { email: current.email } : {}),
+                                    ...(current.accountId
+                                        ? { accountId: current.accountId }
+                                        : {}),
+                                }
+                                : undefined;
+                            upsertAccount(store, { ...refreshed, ...identity });
+                            await saveAccountStore(store);
+                        }
+                        return refreshed;
+                    }
+                    catch (error) {
+                        if (!isPermanentOAuthRefreshFailure(error))
+                            throw error;
+                        failedAuth = latest;
+                        throw error;
+                    }
                 });
-                const current = currentIndex >= 0 ? store.accounts[currentIndex] : undefined;
-                if (!current)
-                    return undefined;
-                return {
-                    ...(current.email ? { email: current.email } : {}),
-                    ...(current.accountId ? { accountId: current.accountId } : {}),
-                };
-            })();
-            upsertAccount(store, { ...refreshed, ...identity });
-            await saveAccountStore(store);
+            }
+            catch (error) {
+                if (!failedAuth || !isPermanentOAuthRefreshFailure(error))
+                    throw error;
+                const removed = await removeAccountByAuth(failedAuth, client);
+                if (!removed)
+                    throw error;
+                client.tui
+                    .showToast({
+                    message: appendToastSessionMarker({
+                        message: removed.active
+                            ? `Removed expired Anthropic account ${removed.removedLabel}, switched to ${removed.activeLabel ?? "next"}`
+                            : `Removed expired Anthropic account ${removed.removedLabel} (no accounts left — re-login required)`,
+                        sessionId: options?.sessionId,
+                    }),
+                    variant: removed.active ? "info" : "error",
+                })
+                    .catch(() => { });
+                if (!removed.active)
+                    throw error;
+            }
         }
-        return refreshed;
-    });
+    })();
     pendingRefresh.set(auth.refresh, refreshPromise);
     return refreshPromise.finally(() => {
         pendingRefresh.delete(auth.refresh);
@@ -846,7 +887,9 @@ const AnthropicAuthPlugin = async ({ serverUrl, directory }) => {
                                 headers: requestHeaders,
                             });
                         };
-                        const freshAuth = await getFreshOAuth(getAuth, client);
+                        const freshAuth = await getFreshOAuth(getAuth, client, {
+                            sessionId,
+                        });
                         if (!freshAuth)
                             return fetch(input, init);
                         let response = await runRequest(freshAuth);
@@ -868,7 +911,9 @@ const AnthropicAuthPlugin = async ({ serverUrl, directory }) => {
                                         variant: "info",
                                     })
                                         .catch(() => { });
-                                    const retryAuth = await getFreshOAuth(getAuth, client);
+                                    const retryAuth = await getFreshOAuth(getAuth, client, {
+                                        sessionId,
+                                    });
                                     if (retryAuth) {
                                         response = await runRequest(retryAuth);
                                     }

package/dist/anthropic-auth-state.js

@@ -7,8 +7,8 @@
 import { homedir } from 'node:os';
 import path from 'node:path';
 import { normalizeAnthropicAccountIdentity, } from './anthropic-account-identity.js';
-import { accountLabel, authFilePath, findCurrentAccountIndex, isOAuthStored, normalizeAccountStore, readJson, upsertAccount as sharedUpsertAccount, withAuthStateLock, writeJson, shouldRotateAuth, } from './oauth-rotation-shared.js';
-export { accountLabel, authFilePath, withAuthStateLock, shouldRotateAuth };
+import { accountLabel, authFilePath, findCurrentAccountIndex, isOAuthStored, isPermanentOAuthRefreshFailure, normalizeAccountStore, readJson, upsertAccount as sharedUpsertAccount, withAuthStateLock, writeJson, shouldRotateAuth, } from './oauth-rotation-shared.js';
+export { accountLabel, authFilePath, withAuthStateLock, shouldRotateAuth, isPermanentOAuthRefreshFailure, };
 // --- Store file path ---
 export function accountsFilePath() {
     if (process.env.XDG_DATA_HOME) {
@@ -114,37 +114,72 @@ export async function rotateAnthropicAccount(auth, client) {
     });
 }
 // --- Remove account ---
+/** Splice account at index and promote next. Caller must hold withAuthStateLock. */
+async function spliceAccountAndPromote({ store, index, client, }) {
+    store.accounts.splice(index, 1);
+    if (store.accounts.length === 0) {
+        store.activeIndex = 0;
+        await saveAccountStore(store);
+        await writeAnthropicAuthFile(undefined);
+        return { store, active: undefined, activeLabel: undefined };
+    }
+    if (store.activeIndex > index) {
+        store.activeIndex -= 1;
+    }
+    else if (store.activeIndex >= store.accounts.length) {
+        store.activeIndex = 0;
+    }
+    const active = store.accounts[store.activeIndex];
+    if (!active)
+        throw new Error('Active Anthropic account disappeared during removal');
+    active.lastUsed = Date.now();
+    await saveAccountStore(store);
+    const nextAuth = {
+        type: 'oauth',
+        refresh: active.refresh,
+        access: active.access,
+        expires: active.expires,
+    };
+    if (client) {
+        await setAnthropicAuth(nextAuth, client);
+    }
+    else {
+        await writeAnthropicAuthFile(nextAuth);
+    }
+    return {
+        store,
+        active: nextAuth,
+        activeLabel: accountLabel(active, store.activeIndex),
+    };
+}
 export async function removeAccount(index) {
     return withAuthStateLock(async () => {
         const store = await loadAccountStore();
         if (!Number.isInteger(index) || index < 0 || index >= store.accounts.length) {
             throw new Error(`Account ${index + 1} does not exist`);
         }
-        store.accounts.splice(index, 1);
-        if (store.accounts.length === 0) {
-            store.activeIndex = 0;
-            await saveAccountStore(store);
-            await writeAnthropicAuthFile(undefined);
-            return { store, active: undefined };
-        }
-        if (store.activeIndex > index) {
-            store.activeIndex -= 1;
-        }
-        else if (store.activeIndex >= store.accounts.length) {
-            store.activeIndex = 0;
-        }
-        const active = store.accounts[store.activeIndex];
-        if (!active)
-            throw new Error('Active Anthropic account disappeared during removal');
-        active.lastUsed = Date.now();
-        await saveAccountStore(store);
-        const nextAuth = {
-            type: 'oauth',
-            refresh: active.refresh,
-            access: active.access,
-            expires: active.expires,
+        return spliceAccountAndPromote({ store, index });
+    });
+}
+/**
+ * Remove the pool entry matching these OAuth credentials and promote the next
+ * account. Used when refresh fails permanently (invalid_grant).
+ */
+export async function removeAccountByAuth(auth, client) {
+    return withAuthStateLock(async () => {
+        const store = await loadAccountStore();
+        const index = store.accounts.findIndex((account) => account.refresh === auth.refresh || account.access === auth.access);
+        if (index < 0)
+            return undefined;
+        const removed = store.accounts[index];
+        if (!removed)
+            return undefined;
+        const removedLabel = accountLabel(removed, index);
+        const result = await spliceAccountAndPromote({ store, index, client });
+        return {
+            removedLabel,
+            activeLabel: result.activeLabel,
+            active: result.active,
         };
-        await writeAnthropicAuthFile(nextAuth);
-        return { store, active: nextAuth };
     });
 }

package/dist/anthropic-auth-state.test.js

@@ -1,9 +1,10 @@
-// Tests Anthropic OAuth account persistence, deduplication, and rotation.
+// Tests Anthropic OAuth account persistence, deduplication, rotation, and
+// permanent refresh-failure removal.
 import { mkdtemp, readFile, rm, mkdir, writeFile } from 'node:fs/promises';
 import { tmpdir } from 'node:os';
 import path from 'node:path';
 import { afterEach, beforeEach, describe, expect, test } from 'vitest';
-import { accountLabel, authFilePath, loadAccountStore, rememberAnthropicOAuth, removeAccount, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
+import { accountLabel, authFilePath, isPermanentOAuthRefreshFailure, loadAccountStore, rememberAnthropicOAuth, removeAccount, removeAccountByAuth, rotateAnthropicAccount, saveAccountStore, shouldRotateAuth, } from './anthropic-auth-state.js';
 const firstAccount = {
     type: 'oauth',
     refresh: 'refresh-first',
@@ -141,6 +142,51 @@ describe('removeAccount', () => {
         expect(authJson.anthropic).toBeUndefined();
     });
 });
+describe('removeAccountByAuth', () => {
+    test('removes matched account, promotes next, and syncs auth.set', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [
+                { ...firstAccount, email: 'dead@example.com', addedAt: 1, lastUsed: 1 },
+                { ...secondAccount, email: 'live@example.com', addedAt: 2, lastUsed: 2 },
+            ],
+        });
+        const authSetCalls = [];
+        const client = {
+            auth: {
+                set: async (input) => {
+                    authSetCalls.push(input);
+                },
+            },
+        };
+        const removed = await removeAccountByAuth(firstAccount, client);
+        const store = await loadAccountStore();
+        expect(removed).toMatchObject({
+            removedLabel: '#1 (dead@example.com)',
+            activeLabel: '#1 (live@example.com)',
+            active: { refresh: 'refresh-second' },
+        });
+        expect(store.accounts).toHaveLength(1);
+        expect(store.accounts[0]?.refresh).toBe('refresh-second');
+        expect(authSetCalls).toHaveLength(1);
+    });
+    test('returns undefined when auth is not in the pool', async () => {
+        await saveAccountStore({
+            version: 1,
+            activeIndex: 0,
+            accounts: [{ ...firstAccount, addedAt: 1, lastUsed: 1 }],
+        });
+        const removed = await removeAccountByAuth({
+            type: 'oauth',
+            refresh: 'unknown-refresh',
+            access: 'unknown-access',
+            expires: 1,
+        }, { auth: { set: async () => { } } });
+        expect(removed).toBeUndefined();
+        expect((await loadAccountStore()).accounts).toHaveLength(1);
+    });
+});
 describe('shouldRotateAuth', () => {
     test('only rotates on rate limit or auth failures', () => {
         expect(shouldRotateAuth(429, '')).toBe(true);
@@ -148,3 +194,10 @@ describe('shouldRotateAuth', () => {
         expect(shouldRotateAuth(400, 'bad request')).toBe(false);
     });
 });
+describe('isPermanentOAuthRefreshFailure', () => {
+    test('detects invalid_grant and expired refresh tokens', () => {
+        expect(isPermanentOAuthRefreshFailure(new Error('HTTP 400 from https://platform.claude.com/v1/oauth/token: {"error": "invalid_grant", "error_description": "Refresh token expired"}'))).toBe(true);
+        expect(isPermanentOAuthRefreshFailure(new Error('ECONNRESET'))).toBe(false);
+        expect(isPermanentOAuthRefreshFailure(new Error('rate_limit_error'))).toBe(false);
+    });
+});

package/dist/channel-management.js

@@ -113,6 +113,10 @@ __pycache__/
 .venv/
 *.egg-info/
 `;
+/** Returns the absolute path to the default kimaki project directory. */
+export function getDefaultKimakiDirectory() {
+    return path.join(getProjectsDir(), 'kimaki');
+}
 const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not connected to a specific OpenCode project or repository.';
 /**
  * Create (or find) the default "kimaki" channel for general-purpose tasks.
@@ -124,7 +128,7 @@ const DEFAULT_CHANNEL_TOPIC = 'General channel for misc tasks with Kimaki. Not c
  * as a fallback for channels created before DB mapping existed.
  */
 export async function createDefaultKimakiChannel({ guild, botName, appId, isGatewayMode, }) {
-    const projectDirectory = path.join(getProjectsDir(), 'kimaki');
+    const projectDirectory = getDefaultKimakiDirectory();
     // Ensure the default kimaki project directory exists before any DB mapping
     // restoration or git setup. Custom data dirs may not have <dataDir>/projects
     // created yet, and later writes assume the full path is present.
@@ -146,11 +150,29 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         directory: projectDirectory,
         channelType: 'text',
     });
-    const mappedChannelInGuild = existingMappings
-        .map((row) => guild.channels.cache.get(row.channel_id))
-        .find((ch) => ch?.type === ChannelType.GuildText);
-    if (mappedChannelInGuild) {
-        logger.log(`Default kimaki channel already exists: ${mappedChannelInGuild.id}`);
+    const mappedRow = existingMappings.find((row) => {
+        const ch = guild.channels.cache.get(row.channel_id);
+        return ch?.type === ChannelType.GuildText;
+    });
+    if (mappedRow) {
+        // Backfill guild_id for rows created before this column existed,
+        // so the tombstone check works if the channel is deleted later.
+        if (mappedRow.guild_id !== guild.id) {
+            await setChannelDirectory({
+                channelId: mappedRow.channel_id,
+                directory: projectDirectory,
+                channelType: 'text',
+                guildId: guild.id,
+            });
+        }
+        logger.log(`Default kimaki channel already exists: ${mappedRow.channel_id}`);
+        return null;
+    }
+    // 1b. If a mapping exists for this guild but the channel is gone from Discord,
+    // it was previously created and then deleted. Don't recreate it.
+    const staleForThisGuild = existingMappings.find((row) => row.guild_id === guild.id);
+    if (staleForThisGuild) {
+        logger.log(`Default kimaki channel was previously provisioned for guild ${guild.name} (${guild.id}) as ${staleForThisGuild.channel_id}, but no longer exists. Skipping recreation.`);
         return null;
     }
     // 2. Fallback: detect existing channel by name+category.
@@ -213,6 +235,7 @@ export async function createDefaultKimakiChannel({ guild, botName, appId, isGate
         channelId: textChannel.id,
         directory: projectDirectory,
         channelType: 'text',
+        guildId: guild.id,
     });
     logger.log(`Created default kimaki channel: #${channelName} (${textChannel.id})`);
     return {

package/dist/cli-commands/project.js

@@ -11,6 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { spawn, execSync } from 'node:child_process';
 import { createLogger, LogPrefix, initLogFile } from '../logger.js';
 import { createDiscordClient, initDatabase, getChannelDirectory, initializeOpencodeForDirectory, createProjectChannels } from '../discord-bot.js';
+import { getDefaultKimakiDirectory } from '../channel-management.js';
 import { getBotTokenWithMode, getThreadSession, getThreadIdBySessionId, getSessionEventSnapshot, getDb, createScheduledTask, listScheduledTasks, cancelScheduledTask, getScheduledTask, updateScheduledTask, getSessionStartSourcesBySessionIds, deleteChannelDirectoryById, findChannelsByDirectory } from '../database.js';
 import { ShareMarkdown } from '../markdown.js';
 import { parseSessionSearchPattern, findFirstSessionSearchHit, buildSessionSearchSnippet, getPartSearchTexts } from '../session-search.js';
@@ -98,6 +99,8 @@ cli
 cli
     .command('project list', 'List all registered projects with their Discord channels')
     .option('--json', 'Output as JSON')
+    .option('--all', 'Include remote projects from other machines (scans Kimaki category in Discord)')
+    .option('-g, --guild <guildId>', 'Discord guild/server ID to scan (used with --all when no local projects exist)')
     .option('--prune', 'Remove stale entries whose Discord channel no longer exists')
     .action(async (options) => {
     await initDatabase();
@@ -106,13 +109,10 @@ cli
         where: { channel_type: 'text' },
         orderBy: { created_at: 'desc' },
     });
-    if (channels.length === 0) {
-        cliLogger.log('No projects registered');
-        process.exit(0);
-    }
     // Fetch Discord channel names and guild IDs via REST API
     const botRow = await getBotTokenWithMode();
     const rest = botRow ? createDiscordRest(botRow.token) : null;
+    const localChannelIds = new Set(channels.map((ch) => ch.channel_id));
     const enriched = await Promise.all(channels.map(async (ch) => {
         let channelName = '';
         let guildId = '';
@@ -132,12 +132,17 @@ cli
                 deleted = isUnknownChannel;
             }
         }
-        return { ...ch, channelName, guildId, deleted };
+        return { ...ch, channelName, guildId, deleted, isLocal: true };
     }));
     // Fetch guild names for unique guild IDs (deduplicated to save API calls)
     const guildNameMap = new Map();
+    // Collect guild IDs from local channels + explicit --guild flag
+    const guildIdsFromChannels = enriched.map((ch) => ch.guildId).filter(Boolean);
+    if (options.guild) {
+        guildIdsFromChannels.push(options.guild);
+    }
+    const uniqueGuildIds = [...new Set(guildIdsFromChannels)];
     if (rest) {
-        const uniqueGuildIds = [...new Set(enriched.map((ch) => ch.guildId).filter(Boolean))];
         await Promise.all(uniqueGuildIds.map(async (guildId) => {
             try {
                 const data = (await rest.get(Routes.guild(guildId)));
@@ -148,15 +153,68 @@ cli
             }
         }));
     }
+    // When --all is passed, scan each guild's channels to find Kimaki category
+    // text channels not in our local DB (projects from other machines).
+    // Fail explicitly when prerequisites are missing so the user doesn't
+    // confuse "scan never ran" with "no remote projects found".
+    let remoteEntries = [];
+    if (options.all) {
+        if (!rest) {
+            cliLogger.error('Discord credentials are required to scan remote projects. Run `kimaki` first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        if (uniqueGuildIds.length === 0) {
+            cliLogger.error('Cannot determine which Discord server to scan. Pass `--guild <guildId>` or register a local project first.');
+            process.exit(EXIT_NO_RESTART);
+        }
+        let guildScanFailures = 0;
+        for (const guildId of uniqueGuildIds) {
+            try {
+                const guildChannels = (await rest.get(Routes.guildChannels(guildId)));
+                // Find Kimaki category channels (type 4 = GuildCategory)
+                const kimakiCategoryIds = new Set(guildChannels
+                    .filter((ch) => ch.type === 4 && /^kimaki(\s|$)/i.test(ch.name))
+                    .map((ch) => ch.id));
+                // Find text channels (type 0) in Kimaki categories that are not in our local DB
+                for (const ch of guildChannels) {
+                    if (ch.type === 0 &&
+                        ch.parent_id &&
+                        kimakiCategoryIds.has(ch.parent_id) &&
+                        !localChannelIds.has(ch.id)) {
+                        remoteEntries.push({
+                            channel_id: ch.id,
+                            directory: '',
+                            channel_type: 'text',
+                            guild_id: guildId,
+                            created_at: null,
+                            channelName: ch.name,
+                            guildId,
+                            deleted: false,
+                            isLocal: false,
+                        });
+                    }
+                }
+            }
+            catch (error) {
+                guildScanFailures++;
+                cliLogger.warn(`Failed to scan guild ${guildNameMap.get(guildId) || guildId}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        if (guildScanFailures === uniqueGuildIds.length) {
+            cliLogger.error('Failed to scan all guilds. Check bot permissions or try again.');
+            process.exit(EXIT_NO_RESTART);
+        }
+    }
     // Build final enriched entries with guild names resolved
-    const enrichedWithGuild = enriched.map((ch) => ({
+    const allEntries = [...enriched, ...remoteEntries];
+    const enrichedWithGuild = allEntries.map((ch) => ({
         ...ch,
         guildName: ch.guildId ? (guildNameMap.get(ch.guildId) || '') : '',
     }));
     // Warn on stderr if the same directory appears in multiple channels (multi-guild duplicates)
     const directoryCounts = new Map();
     for (const ch of enrichedWithGuild) {
-        if (!ch.deleted) {
+        if (!ch.deleted && ch.directory) {
             directoryCounts.set(ch.directory, (directoryCounts.get(ch.directory) || 0) + 1);
         }
     }
@@ -168,7 +226,10 @@ cli
     // Prune stale entries if requested
     let finalEntries = enrichedWithGuild;
     if (options.prune) {
-        const stale = finalEntries.filter((ch) => ch.deleted);
+        // Skip default kimaki directory tombstones — those are preserved
+        // intentionally so the tutorial channel isn't recreated after deletion.
+        const defaultDir = getDefaultKimakiDirectory();
+        const stale = finalEntries.filter((ch) => ch.deleted && ch.isLocal && ch.directory !== defaultDir);
         if (stale.length === 0) {
             cliLogger.log('No stale channels to prune');
         }
@@ -185,28 +246,39 @@ cli
             process.exit(0);
         }
     }
+    if (finalEntries.length === 0) {
+        cliLogger.log('No projects registered');
+        process.exit(0);
+    }
     if (options.json) {
         const output = finalEntries.map((ch) => ({
             channel_id: ch.channel_id,
             channel_name: ch.channelName,
             guild_id: ch.guildId,
             guild_name: ch.guildName,
-            directory: ch.directory,
-            folder_name: path.basename(ch.directory),
+            directory: ch.directory || null,
+            folder_name: ch.directory ? path.basename(ch.directory) : null,
             deleted: ch.deleted,
+            is_local: ch.isLocal,
         }));
         console.log(JSON.stringify(output, null, 2));
         process.exit(0);
     }
     for (const ch of finalEntries) {
-        const folderName = path.basename(ch.directory);
         const deletedTag = ch.deleted ? ' (deleted from Discord)' : '';
+        const remoteTag = !ch.isLocal ? ' [remote]' : '';
         const channelLabel = ch.channelName ? `#${ch.channelName}` : ch.channel_id;
         const guildLabel = ch.guildName || ch.guildId || '';
         const guildSuffix = guildLabel ? ` (${guildLabel})` : '';
-        console.log(`\n${channelLabel}${guildSuffix}${deletedTag}`);
-        console.log(`   Folder: ${folderName}`);
-        console.log(`   Directory: ${ch.directory}`);
+        console.log(`\n${channelLabel}${guildSuffix}${deletedTag}${remoteTag}`);
+        if (ch.isLocal && ch.directory) {
+            const folderName = path.basename(ch.directory);
+            console.log(`   Folder: ${folderName}`);
+            console.log(`   Directory: ${ch.directory}`);
+        }
+        else if (!ch.isLocal) {
+            console.log(`   (Not registered on this machine)`);
+        }
         console.log(`   Channel ID: ${ch.channel_id}`);
         if (ch.guildId) {
             console.log(`   Guild ID: ${ch.guildId}`);